@openma/deepseek-harness-acp 0.4.9 → 0.4.10-beta.2

package/README.md

@@ -36,13 +36,19 @@ touch your editor config — it reuses the key you saved in the dsh Web UI, or
 | Best for | Getting started in one command | Living inside your dsh setup |
 | Install | `npm i -g @openma/deepseek-harness-acp` | `dsh plugin --profile acp add -w @openma/deepseek-harness-acp` |
 | Zed runs | `dsh-acp` | `dsh --profile acp` |
-| Harness | Your installed dsh — or the vendored fallback when none exists | The dsh that owns the profile |
+| Harness | Your installed dsh — or the npm-installed peer when none exists | The dsh that owns the profile |
 | Composition | dsh-base + this bundle (profile machinery booted in-process) | dsh-base + this bundle + your profile's own patches |
 
 Both shapes share `$DSH_HOME`: the same credential store, settings, presets,
 and session logs as `dsh web` — conversations started in the Web UI can be
 listed and loaded from the editor.
 
+Other dsh surfaces can mount the transport-independent
+`@openma/deepseek-harness-acp/plugin` on their Base Host tree and own the
+transport adapter. The TUI profile uses this path: it starts a separate TUI
+Client process and connects ACP over that process's standard stdin/stdout; it
+does not start `dsh-acp` or use an in-process Client stream.
+
 ### A · Standalone server
 
 ```bash
@@ -61,7 +67,7 @@ dsh-acp login        # interactive; or save the key in the dsh Web UI
 
 Self-contained: it finds your DeepSeek Harness via `--dsh-path` / `DSH_PATH`,
 its own tree, `./node_modules`, `dsh` on PATH, or `npm root -g` — and ships a
-vendored harness runtime as the **last** candidate, so it works out of the box
+npm-installed harness peer as the **last** candidate, so it works out of the box
 and always prefers the dsh you installed. When a real
 `$DSH_HOME/profiles/acp` exists, that profile owns the composition.
 
@@ -169,7 +175,7 @@ ACP client (Zed, …)
 dsh-acp
    ├─ src/profile-boot.ts     boots the harness's own profile machinery
    │                          (dsh-base + this bundle + $DSH_HOME layers)
-   ├─ src/harness.ts          host discovery (DSH_PATH → cwd → PATH → npm -g → vendored)
+   ├─ src/harness.ts          host discovery (DSH_PATH → cwd → PATH → npm -g → npm peer)
    └─ src/bridge/             the ACP bridge (a cordis plugin)
         ├─ index.ts           sessions, prompts, cancel, modes, options,
         │                     commands, credentials, MCP mounts

package/cordis.patch.yml

@@ -97,22 +97,15 @@
   disabled: true
 
 - insert:
-    # Agent presets: per-session model-facing compositions (persona, tools,
-    # compaction). The dsh CLI injects its shipped root into any row with this
-    # id, so standard/code/minimal/creator are available and ACP session modes
-    # surface them (~/.dsh/agent-presets adds user-authored ones).
-    - id: agent-presets
-      name: '@deepseek-ai/dsh-agent-presets'
-      config:
-        default: standard
-
-    # Same host row the web-app bundle mounts. Without it, preset "cordis"
-    # never activates: tool-cordis waits for dynamicCordisRunner, cordisInspect.
-    - id: cordis-host-runner
-      name: '@deepseek-ai/dsh-cordis-host-runner'
-
-    - id: acp-bridge
-      name: '@openma/deepseek-harness-acp/bridge'
+    # The same complete Cordis plugin embedded by other surfaces. It owns the
+    # preset plane and transport-independent ACP server, but no transport.
+    - id: acp-plugin
+      name: '@openma/deepseek-harness-acp/plugin'
       config:
         model: !!js process.env.DSH_MODEL
         permissionMode: !!js process.env.DSH_PERMISSION_MODE ?? 'workspace-write'
+
+    # The ordinary ACP profile owns stdio. Embedded surfaces replace only this
+    # adapter and reuse the exact same plugin contract above.
+    - id: acp-bridge
+      name: '@openma/deepseek-harness-acp/stdio'

package/dist/bridge.js

@@ -44,7 +44,21 @@ var init_self_harness = __esm({
   }
 });
 
+// src/bundle.ts
+import { ndJsonStream as ndJsonStream2 } from "@agentclientprotocol/sdk";
+import { Readable as Readable2, Writable as Writable2 } from "node:stream";
+
 // src/bridge/index.ts
+var bridge_exports = {};
+__export(bridge_exports, {
+  answerFromElicitation: () => answerFromElicitation,
+  apply: () => apply,
+  askUserQuestionsOverAcp: () => askUserQuestionsOverAcp,
+  inject: () => inject,
+  installAcpUserQuestionProvider: () => installAcpUserQuestionProvider,
+  name: () => name,
+  questionsToElicitation: () => questionsToElicitation
+});
 import { randomUUID } from "node:crypto";
 import { isAbsolute } from "node:path";
 import { Readable, Writable } from "node:stream";
@@ -1113,6 +1127,36 @@ ${contextBlock(resource.uri, resource.text)}
   };
 }
 
+// src/bridge/cordis-protocol.ts
+var CORDIS_PROTOCOL = 0;
+var CORDIS_CAPABILITY = Object.freeze({ protocol: CORDIS_PROTOCOL });
+var CORDIS_METHODS = Object.freeze({
+  inspectSync: "_dsh/cordis/inspect/sync",
+  inspectResolve: "_dsh/cordis/inspect/resolve",
+  inspectQuery: "_dsh/cordis/inspect/query",
+  inspectQueryResolved: "_dsh/cordis/inspect/query-resolved",
+  runHost: "_dsh/cordis/run/host",
+  getClientCode: "_dsh/cordis/run/client-code",
+  resolveRequestRun: "_dsh/cordis/run/resolve",
+  requestRun: "_dsh/cordis/run/request",
+  requestRunResolved: "_dsh/cordis/run/request-resolved",
+  userRun: "_dsh/cordis/run/user",
+  settleUserRun: "_dsh/cordis/run/settle",
+  pluginInvoke: "_dsh/cordis/plugin/invoke",
+  pluginsList: "_dsh/cordis/plugins/list",
+  pluginStart: "_dsh/cordis/plugins/start",
+  pluginStop: "_dsh/cordis/plugins/stop",
+  pluginRetract: "_dsh/cordis/plugins/retract"
+});
+function advertisesCordis(meta) {
+  if (meta === null || typeof meta !== "object" || Array.isArray(meta)) return false;
+  const dsh = meta["dsh"];
+  if (dsh === null || typeof dsh !== "object" || Array.isArray(dsh)) return false;
+  const cordis = dsh["cordis"];
+  if (cordis === null || typeof cordis !== "object" || Array.isArray(cordis)) return false;
+  return cordis["protocol"] === CORDIS_PROTOCOL;
+}
+
 // src/bridge/rpc.ts
 var AcpRpc = class {
   handlers = /* @__PURE__ */ new Map();
@@ -1126,11 +1170,14 @@ var AcpRpc = class {
   }
   /**
    * Register a bridge-owned request method intercepted before the ACP SDK.
-   * @param method - JSON-RPC method name (e.g. `tui/refresh`).
+   * @param method - JSON-RPC extension method (e.g. `_dsh/cordis/inspect/sync`).
    * @param handler - implementation.
    * @returns disposer.
    */
   registerMethod(method, handler) {
+    if (!method.startsWith("_")) {
+      throw new Error(`acpRpc: extension method ${JSON.stringify(method)} must start with "_"`);
+    }
     if (this.handlers.has(method)) {
       throw new Error(`acpRpc: method ${JSON.stringify(method)} is already registered`);
     }
@@ -1165,11 +1212,14 @@ var AcpRpc = class {
     }
   }
   /**
-   * Send a JSON-RPC notification on the ACP stream (e.g. `tui/snapshot`).
+   * Send a JSON-RPC extension notification on the ACP stream.
    * @param method - notification method.
    * @param params - payload.
    */
   notify(method, params) {
+    if (!method.startsWith("_")) {
+      throw new Error(`acpRpc: extension notification ${JSON.stringify(method)} must start with "_"`);
+    }
     const write = this.writeJson;
     if (write === void 0) return;
     write(params === void 0 ? { jsonrpc: "2.0", method } : { jsonrpc: "2.0", method, params });
@@ -1214,20 +1264,19 @@ function muxAcpStream(stream, rpc) {
 function installTuiClientPlane(ctx, rpc, opts) {
   const { findAgent, advertisement } = opts;
   ctx.effect(
-    () => rpc.registerMethod("tui/inspect-sync", (params) => {
+    () => rpc.registerMethod(CORDIS_METHODS.inspectSync, (params) => {
       const inspect = optionalInspect(ctx);
       if (inspect === void 0) {
         throw new Error("this agent has no Cordis inspect registry");
       }
       const providers = readProviders(params);
       inspect.syncClientManifest(providers);
-      advertisement.advertised = true;
       return { ok: true };
     }),
-    "acp-bridge: tui/inspect-sync"
+    "acp-bridge: cordis/inspect-sync"
   );
   ctx.effect(
-    () => rpc.registerMethod("tui/inspect-resolve", (params) => {
+    () => rpc.registerMethod(CORDIS_METHODS.inspectResolve, (params) => {
       const inspect = optionalInspect(ctx);
       if (inspect === void 0) {
         throw new Error("this agent has no Cordis inspect registry");
@@ -1237,10 +1286,10 @@ function installTuiClientPlane(ctx, rpc, opts) {
       const requestId = readString(body, "requestId");
       return inspect.resolveClientQuery(agent, requestId, body["resolution"]);
     }),
-    "acp-bridge: tui/inspect-resolve"
+    "acp-bridge: cordis/inspect-resolve"
   );
   ctx.effect(
-    () => rpc.registerMethod("tui/run-host-half", async (params) => {
+    () => rpc.registerMethod(CORDIS_METHODS.runHost, async (params) => {
       const runner = optionalRunner(ctx);
       if (runner === void 0) {
         throw new Error("this agent has no dynamic Cordis runner");
@@ -1257,10 +1306,10 @@ function installTuiClientPlane(ctx, rpc, opts) {
         body["approveFutureVersions"] === true
       );
     }),
-    "acp-bridge: tui/run-host-half"
+    "acp-bridge: cordis/run-host-half"
   );
   ctx.effect(
-    () => rpc.registerMethod("tui/get-client-code", (params) => {
+    () => rpc.registerMethod(CORDIS_METHODS.getClientCode, (params) => {
       const runner = optionalRunner(ctx);
       if (runner === void 0) {
         throw new Error("this agent has no dynamic Cordis runner");
@@ -1273,10 +1322,10 @@ function installTuiClientPlane(ctx, rpc, opts) {
         readString(body, "pluginRunId")
       );
     }),
-    "acp-bridge: tui/get-client-code"
+    "acp-bridge: cordis/get-client-code"
   );
   ctx.effect(
-    () => rpc.registerMethod("tui/resolve-request-run", async (params) => {
+    () => rpc.registerMethod(CORDIS_METHODS.resolveRequestRun, async (params) => {
       const runner = optionalRunner(ctx);
       if (runner === void 0) {
         throw new Error("this agent has no dynamic Cordis runner");
@@ -1287,10 +1336,10 @@ function installTuiClientPlane(ctx, rpc, opts) {
         body["resolution"]
       );
     }),
-    "acp-bridge: tui/resolve-request-run"
+    "acp-bridge: cordis/resolve-request-run"
   );
   ctx.effect(
-    () => rpc.registerMethod("tui/invoke", async (params) => {
+    () => rpc.registerMethod(CORDIS_METHODS.pluginInvoke, async (params) => {
       const runner = optionalRunner(ctx);
       if (runner === void 0) {
         throw new Error("this agent has no dynamic Cordis runner");
@@ -1304,28 +1353,28 @@ function installTuiClientPlane(ctx, rpc, opts) {
         body["args"] ?? null
       );
     }),
-    "acp-bridge: tui/invoke"
+    "acp-bridge: cordis/invoke"
   );
   ctx.effect(
-    () => rpc.registerMethod("tui/list-plugins", (params) => {
+    () => rpc.registerMethod(CORDIS_METHODS.pluginsList, (params) => {
       const runner = requireRunnerMethod(ctx, "listPlugins");
       const body = asObject(params);
       const agent = requireAgent(findAgent, readString(body, "agentId"));
       return runner.listPlugins(agent);
     }),
-    "acp-bridge: tui/list-plugins"
+    "acp-bridge: cordis/list-plugins"
   );
   ctx.effect(
-    () => rpc.registerMethod("tui/stop-plugin", async (params) => {
+    () => rpc.registerMethod(CORDIS_METHODS.pluginStop, async (params) => {
       const runner = requireRunnerMethod(ctx, "stopFromPanel");
       const body = asObject(params);
       const agent = requireAgent(findAgent, readString(body, "agentId"));
       return await runner.stopFromPanel(agent, readString(body, "pluginId"));
     }),
-    "acp-bridge: tui/stop-plugin"
+    "acp-bridge: cordis/stop-plugin"
   );
   ctx.effect(
-    () => rpc.registerMethod("tui/start-plugin", async (params) => {
+    () => rpc.registerMethod(CORDIS_METHODS.pluginStart, async (params) => {
       const runner = requireRunnerMethod(ctx, "listPlugins");
       const body = asObject(params);
       const agentId = readString(body, "agentId");
@@ -1353,7 +1402,7 @@ function installTuiClientPlane(ctx, rpc, opts) {
       const pluginRunId = readString(started, "pluginRunId");
       const startedHere = started["startedHere"] !== false;
       if (pkg.hasClientHalf) {
-        rpc.notify("tui/user-run", {
+        rpc.notify(CORDIS_METHODS.userRun, {
           agentId,
           pluginId,
           packageId,
@@ -1365,10 +1414,10 @@ function installTuiClientPlane(ctx, rpc, opts) {
       }
       return { ok: true, status: "starting", pluginId, packageId, pluginRunId };
     }),
-    "acp-bridge: tui/start-plugin"
+    "acp-bridge: cordis/start-plugin"
   );
   ctx.effect(
-    () => rpc.registerMethod("tui/settle-user-run", async (params) => {
+    () => rpc.registerMethod(CORDIS_METHODS.settleUserRun, async (params) => {
       const runner = requireRunnerMethod(ctx, "settleUserRun");
       const body = asObject(params);
       const agent = requireAgent(findAgent, readString(body, "agentId"));
@@ -1378,27 +1427,27 @@ function installTuiClientPlane(ctx, rpc, opts) {
         body["resolution"]
       );
     }),
-    "acp-bridge: tui/settle-user-run"
+    "acp-bridge: cordis/settle-user-run"
   );
   ctx.on("cordis/inspect-query", (request) => {
     if (!advertisement.advertised) return;
-    rpc.notify("tui/inspect-query", request);
+    rpc.notify(CORDIS_METHODS.inspectQuery, request);
   });
   ctx.on("cordis/inspect-query-resolved", (resolved) => {
     if (!advertisement.advertised) return;
-    rpc.notify("tui/inspect-query-resolved", resolved);
+    rpc.notify(CORDIS_METHODS.inspectQueryResolved, resolved);
   });
   ctx.on("cordis/request-run", (request) => {
     if (!advertisement.advertised) return;
-    rpc.notify("tui/request-run", request);
+    rpc.notify(CORDIS_METHODS.requestRun, request);
   });
   ctx.on("cordis/request-run-resolved", (resolved) => {
     if (!advertisement.advertised) return;
-    rpc.notify("tui/request-run-resolved", resolved);
+    rpc.notify(CORDIS_METHODS.requestRunResolved, resolved);
   });
   ctx.on("cordis/dynamic-retract", (retracted) => {
     if (!advertisement.advertised) return;
-    rpc.notify("tui/dynamic-retract", retracted);
+    rpc.notify(CORDIS_METHODS.pluginRetract, retracted);
   });
 }
 function optionalInspect(ctx) {
@@ -1465,6 +1514,7 @@ function readProviders(params) {
 }
 
 // src/bridge/user-questions.ts
+import { Service } from "@deepseek-ai/cordis";
 import {
   UserQuestionError
 } from "@deepseek-ai/dsh-user-questions";
@@ -1591,25 +1641,48 @@ async function askUserQuestionsOverAcp(request, sessionId, create) {
   }
   return answer;
 }
+var ROUTERS_KEY = /* @__PURE__ */ Symbol.for("@openma/deepseek-harness-acp/user-question-routers");
+var routers = globalThis[ROUTERS_KEY] ??= /* @__PURE__ */ new WeakMap();
 function installAcpUserQuestionProvider(service, options) {
-  return service.registerProvider({
-    async ask(request) {
-      if (!options.formSupported()) {
-        throw new UserQuestionError(
-          "the ACP client does not support form elicitation",
-          "CLIENT_UNSUPPORTED"
-        );
-      }
-      const sessionId = options.sessionIdForRequest(request);
-      if (sessionId === void 0) {
+  const tracked = service[Service.tracker];
+  const owner = typeof tracked === "object" && tracked !== null ? tracked : service;
+  let router = routers.get(owner);
+  if (router === void 0) {
+    const routes = [];
+    const disposeProvider = service.registerProvider({
+      async ask(request) {
+        for (let index = routes.length - 1; index >= 0; index -= 1) {
+          const route = routes[index];
+          const sessionId = route?.sessionIdForRequest(request);
+          if (route === void 0 || sessionId === void 0) continue;
+          if (!route.formSupported()) {
+            throw new UserQuestionError(
+              "the ACP client does not support form elicitation",
+              "CLIENT_UNSUPPORTED"
+            );
+          }
+          return askUserQuestionsOverAcp(request, sessionId, route.create);
+        }
         throw new UserQuestionError(
           "ACP user interaction requires a live root session",
           "ASK_MISSING_AGENT"
         );
       }
-      return askUserQuestionsOverAcp(request, sessionId, options.create);
-    }
-  });
+    });
+    router = { routes, disposeProvider };
+    routers.set(owner, router);
+  }
+  router.routes.push(options);
+  let active = true;
+  return () => {
+    if (!active) return;
+    active = false;
+    const index = router.routes.indexOf(options);
+    if (index >= 0) router.routes.splice(index, 1);
+    if (router.routes.length !== 0) return;
+    routers.delete(owner);
+    router.disposeProvider();
+  };
 }
 
 // src/bridge/presets.ts
@@ -2581,14 +2654,13 @@ async function apply(ctx, config = {}) {
         clientTerminalOutput = capsMeta !== null && typeof capsMeta === "object" ? capsMeta["terminal_output"] === true : false;
         clientSubagentTranscript = capsMeta !== null && typeof capsMeta === "object" ? capsMeta["subagent-transcript"] === true : false;
         clientElicitationForm = params.clientCapabilities?.elicitation?.form !== void 0 && params.clientCapabilities.elicitation.form !== null;
-        if (capsMeta !== null && typeof capsMeta === "object" && capsMeta["tuiInspect"] === true) {
-          tuiClient.advertised = true;
-        }
+        tuiClient.advertised = advertisesCordis(capsMeta);
         const providers = await listProviderRoutes();
         return {
           protocolVersion: typeof requested === "number" && requested >= 1 && requested < PROTOCOL_VERSION ? requested : PROTOCOL_VERSION,
           agentInfo: { name: "dsh-acp", title: "DeepSeek Harness", version: VERSION },
           agentCapabilities: {
+            _meta: { dsh: { cordis: { ...CORDIS_CAPABILITY } } },
             loadSession: true,
             promptCapabilities: {
               image: attachmentIngestOf(ctx.get("attachments")) !== void 0,
@@ -3082,20 +3154,23 @@ async function apply(ctx, config = {}) {
 
 // src/bundle.ts
 init_self_harness();
-var name2 = name;
+var name2 = "acp-bridge";
 var inject2 = inject;
-function apply2(ctx, config) {
-  apply(ctx, {
-    ...config.provider !== void 0 ? { provider: config.provider } : {},
-    ...config.model !== void 0 ? { model: config.model } : {},
-    ...config.models !== void 0 ? { models: config.models } : {},
-    ...config.maxTokens !== void 0 ? { maxTokens: config.maxTokens } : {},
-    ...config.permissionMode !== void 0 ? { permissionMode: config.permissionMode } : {},
-    harness: selfHarness()
-  });
+function nodeAcpStream(input, output) {
+  return ndJsonStream2(
+    Writable2.toWeb(output),
+    Readable2.toWeb(input)
+  );
+}
+function apply2(ctx, config = {}) {
+  const stream = nodeAcpStream(process.stdin, process.stdout);
+  const server = ctx.get("acpServer");
+  if (server !== void 0) return server.connect(stream);
+  return ctx.plugin(bridge_exports, { ...config, stream, harness: selfHarness() });
 }
 export {
   apply2 as apply,
   inject2 as inject,
-  name2 as name
+  name2 as name,
+  nodeAcpStream
 };

package/dist/index.js

@@ -135,9 +135,9 @@ function resolveHost(explicit) {
   const globalNpm = hostFromGlobalNpm();
   if (globalNpm !== void 0) return globalNpm;
   probed.push("npm root -g");
-  const own = hostAt(dirname(fileURLToPath(import.meta.url)), "dsh-acp package tree (vendored)");
+  const own = hostAt(dirname(fileURLToPath(import.meta.url)), "dsh-acp package tree (npm peer)");
   if (own !== void 0) return own;
-  probed.push("dsh-acp package tree (vendored)");
+  probed.push("dsh-acp package tree (npm peer)");
   throw new HarnessNotFoundError(probed);
 }
 
@@ -151,13 +151,19 @@ function ownRoot() {
   return dirname2(createRequire(import.meta.url).resolve("../package.json"));
 }
 var OWN_BRIDGE_SPECIFIER = "@openma/deepseek-harness-acp/bridge";
-function rewriteBridgeRows(row, absoluteEntry) {
-  if (row["name"] === OWN_BRIDGE_SPECIFIER) row["name"] = absoluteEntry;
+var OWN_SERVER_SPECIFIER = "@openma/deepseek-harness-acp/server";
+var OWN_PLUGIN_SPECIFIER = "@openma/deepseek-harness-acp/plugin";
+var OWN_STDIO_SPECIFIER = "@openma/deepseek-harness-acp/stdio";
+function rewriteOwnRows(row, entries) {
+  if (row["name"] === OWN_BRIDGE_SPECIFIER) row["name"] = entries.bridge;
+  if (row["name"] === OWN_SERVER_SPECIFIER) row["name"] = entries.server;
+  if (row["name"] === OWN_PLUGIN_SPECIFIER) row["name"] = entries.plugin;
+  if (row["name"] === OWN_STDIO_SPECIFIER) row["name"] = entries.stdio;
   const insert = row["insert"];
   if (Array.isArray(insert)) {
     for (const nested of insert) {
       if (nested !== null && typeof nested === "object") {
-        rewriteBridgeRows(nested, absoluteEntry);
+        rewriteOwnRows(nested, entries);
       }
     }
   }
@@ -231,6 +237,12 @@ async function bootAcpProfile(host, overrides) {
   let bareModuleBaseUrl = pathToFileURL2(dshDir + sep2).href;
   const distBridge = join2(ownRoot(), "dist", "bridge.js");
   const bridgeEntry = import.meta.url.endsWith(".ts") || !existsSync2(distBridge) ? join2(ownRoot(), "src", "bundle.ts") : distBridge;
+  const distServer = join2(ownRoot(), "dist", "server.js");
+  const serverEntry = import.meta.url.endsWith(".ts") || !existsSync2(distServer) ? join2(ownRoot(), "src", "server.ts") : distServer;
+  const distPlugin = join2(ownRoot(), "dist", "plugin.js");
+  const pluginEntry = import.meta.url.endsWith(".ts") || !existsSync2(distPlugin) ? join2(ownRoot(), "src", "plugin.ts") : distPlugin;
+  const distStdio = join2(ownRoot(), "dist", "stdio.js");
+  const stdioEntry = import.meta.url.endsWith(".ts") || !existsSync2(distStdio) ? join2(ownRoot(), "src", "stdio.ts") : distStdio;
   const realProfileDir = join2(home, "profiles", "acp");
   if (existsSync2(join2(realProfileDir, "package.json"))) {
     appBoot.healProfilesModuleFallback(dshPkgPath);
@@ -255,7 +267,14 @@ async function bootAcpProfile(host, overrides) {
     bundlePatches.push(...loadBundleLayer(appBoot, bundle));
     logDebug(`profile: added bundle ${bundle}`);
   }
-  for (const row of bundlePatches) rewriteBridgeRows(row, bridgeEntry);
+  for (const row of bundlePatches) {
+    rewriteOwnRows(row, {
+      bridge: bridgeEntry,
+      server: serverEntry,
+      plugin: pluginEntry,
+      stdio: stdioEntry
+    });
+  }
   const homePatchPath = join2(home, "cordis.patch.yml");
   const homePatches = appBoot.loadOptionalPatches(BIN, homePatchPath) ?? [];
   const rows = /* @__PURE__ */ new Map();