@copilotkitnext/sqlite-runner 0.0.22-alpha.0 → 0.0.22-alpha.2

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
 
-> @copilotkitnext/sqlite-runner@0.0.22-alpha.0 build /Users/mme/Projects/CopilotKit2/threads-final-review/packages/sqlite-runner
+> @copilotkitnext/sqlite-runner@0.0.22-alpha.2 build /Users/ran/Desktop/vnext_experimental/packages/sqlite-runner
 > tsup
 
 CLI Building entry: src/index.ts
 CLI Using tsconfig: tsconfig.json
 CLI tsup v8.5.0
-CLI Using tsup config: /Users/mme/Projects/CopilotKit2/threads-final-review/packages/sqlite-runner/tsup.config.ts
+CLI Using tsup config: /Users/ran/Desktop/vnext_experimental/packages/sqlite-runner/tsup.config.ts
 CLI Target: es2022
 CLI Cleaning output folder
 CJS Build start
 ESM Build start
-CJS dist/index.js     8.08 KB
-CJS dist/index.js.map 11.82 KB
+ESM dist/index.mjs     11.55 KB
+ESM dist/index.mjs.map 22.22 KB
+ESM ⚡️ Build success in 15ms
+CJS dist/index.js     13.32 KB
+CJS dist/index.js.map 22.31 KB
 CJS ⚡️ Build success in 16ms
-ESM dist/index.mjs     6.37 KB
-ESM dist/index.mjs.map 11.70 KB
-ESM ⚡️ Build success in 16ms
 DTS Build start
-DTS ⚡️ Build success in 1333ms
-DTS dist/index.d.ts  1.69 KB
-DTS dist/index.d.mts 1.69 KB
+DTS ⚡️ Build success in 848ms
+DTS dist/index.d.ts  1009.00 B
+DTS dist/index.d.mts 1009.00 B

package/dist/index.d.mts

@@ -1,46 +1,26 @@
-import * as _ag_ui_client from '@ag-ui/client';
-import { BaseEvent, RunAgentInput } from '@ag-ui/client';
-import { AgentRunnerBase } from '@copilotkitnext/runtime';
+import { AgentRunner, AgentRunnerRunRequest, AgentRunnerConnectRequest, AgentRunnerIsRunningRequest, AgentRunnerStopRequest } from '@copilotkitnext/runtime';
 import { Observable } from 'rxjs';
+import { BaseEvent } from '@ag-ui/client';
 
 interface SqliteAgentRunnerOptions {
     dbPath?: string;
 }
-declare class SqliteAgentRunner extends AgentRunnerBase {
+declare class SqliteAgentRunner extends AgentRunner {
     private db;
-    private channels;
     constructor(options?: SqliteAgentRunnerOptions);
-    private static initializeSchema;
-    protected acquireRun(threadId: string, runId: string): Promise<boolean>;
-    protected releaseRun(threadId: string): Promise<void>;
-    protected isRunningState(threadId: string): Promise<boolean>;
-    protected listRuns(threadId: string): Promise<Array<{
-        runId: string;
-        events: BaseEvent[];
-        createdAt: number;
-    }>>;
-    protected saveRun(threadId: string, runId: string, events: BaseEvent[], input: RunAgentInput, parentRunId: string | null): Promise<void>;
-    protected pageThreads(params: {
-        scope?: any;
-        limit?: number;
-        offset?: number;
-    }): Promise<{
-        threadIds: string[];
-        total: number;
-    }>;
-    protected deleteThreadStorage(threadId: string): Promise<void>;
-    private ensureChannel;
-    protected publishLive(threadId: string, event: BaseEvent): void;
-    protected completeLive(threadId: string): void;
-    protected subscribeLive(threadId: string): Observable<BaseEvent>;
-    protected closeLive(threadId: string): Promise<void>;
-    connect(request: {
-        threadId: string;
-    }): Observable<{
-        type: _ag_ui_client.EventType;
-        timestamp?: number | undefined;
-        rawEvent?: any;
-    }>;
+    private initializeSchema;
+    private storeRun;
+    private getHistoricRuns;
+    private getLatestRunId;
+    private setRunState;
+    private getRunState;
+    run(request: AgentRunnerRunRequest): Observable<BaseEvent>;
+    connect(request: AgentRunnerConnectRequest): Observable<BaseEvent>;
+    isRunning(request: AgentRunnerIsRunningRequest): Promise<boolean>;
+    stop(request: AgentRunnerStopRequest): Promise<boolean | undefined>;
+    /**
+     * Close the database connection (for cleanup)
+     */
     close(): void;
 }
 

package/dist/index.d.ts

@@ -1,46 +1,26 @@
-import * as _ag_ui_client from '@ag-ui/client';
-import { BaseEvent, RunAgentInput } from '@ag-ui/client';
-import { AgentRunnerBase } from '@copilotkitnext/runtime';
+import { AgentRunner, AgentRunnerRunRequest, AgentRunnerConnectRequest, AgentRunnerIsRunningRequest, AgentRunnerStopRequest } from '@copilotkitnext/runtime';
 import { Observable } from 'rxjs';
+import { BaseEvent } from '@ag-ui/client';
 
 interface SqliteAgentRunnerOptions {
     dbPath?: string;
 }
-declare class SqliteAgentRunner extends AgentRunnerBase {
+declare class SqliteAgentRunner extends AgentRunner {
     private db;
-    private channels;
     constructor(options?: SqliteAgentRunnerOptions);
-    private static initializeSchema;
-    protected acquireRun(threadId: string, runId: string): Promise<boolean>;
-    protected releaseRun(threadId: string): Promise<void>;
-    protected isRunningState(threadId: string): Promise<boolean>;
-    protected listRuns(threadId: string): Promise<Array<{
-        runId: string;
-        events: BaseEvent[];
-        createdAt: number;
-    }>>;
-    protected saveRun(threadId: string, runId: string, events: BaseEvent[], input: RunAgentInput, parentRunId: string | null): Promise<void>;
-    protected pageThreads(params: {
-        scope?: any;
-        limit?: number;
-        offset?: number;
-    }): Promise<{
-        threadIds: string[];
-        total: number;
-    }>;
-    protected deleteThreadStorage(threadId: string): Promise<void>;
-    private ensureChannel;
-    protected publishLive(threadId: string, event: BaseEvent): void;
-    protected completeLive(threadId: string): void;
-    protected subscribeLive(threadId: string): Observable<BaseEvent>;
-    protected closeLive(threadId: string): Promise<void>;
-    connect(request: {
-        threadId: string;
-    }): Observable<{
-        type: _ag_ui_client.EventType;
-        timestamp?: number | undefined;
-        rawEvent?: any;
-    }>;
+    private initializeSchema;
+    private storeRun;
+    private getHistoricRuns;
+    private getLatestRunId;
+    private setRunState;
+    private getRunState;
+    run(request: AgentRunnerRunRequest): Observable<BaseEvent>;
+    connect(request: AgentRunnerConnectRequest): Observable<BaseEvent>;
+    isRunning(request: AgentRunnerIsRunningRequest): Promise<boolean>;
+    stop(request: AgentRunnerStopRequest): Promise<boolean | undefined>;
+    /**
+     * Close the database connection (for cleanup)
+     */
     close(): void;
 }
 

package/dist/index.js

@@ -36,12 +36,13 @@ module.exports = __toCommonJS(index_exports);
 
 // src/sqlite-runner.ts
 var import_runtime = require("@copilotkitnext/runtime");
-var import_better_sqlite3 = __toESM(require("better-sqlite3"));
 var import_rxjs = require("rxjs");
+var import_client = require("@ag-ui/client");
+var import_better_sqlite3 = __toESM(require("better-sqlite3"));
 var SCHEMA_VERSION = 1;
-var SqliteAgentRunner = class _SqliteAgentRunner extends import_runtime.AgentRunnerBase {
+var ACTIVE_CONNECTIONS = /* @__PURE__ */ new Map();
+var SqliteAgentRunner = class extends import_runtime.AgentRunner {
   db;
-  channels = /* @__PURE__ */ new Map();
   constructor(options = {}) {
     super();
     const dbPath = options.dbPath ?? ":memory:";
@@ -50,12 +51,11 @@ var SqliteAgentRunner = class _SqliteAgentRunner extends import_runtime.AgentRun
         "better-sqlite3 is required for SqliteAgentRunner but was not found.\nPlease install it in your project:\n  npm install better-sqlite3\n  or\n  pnpm add better-sqlite3\n  or\n  yarn add better-sqlite3\n\nIf you don't need persistence, use InMemoryAgentRunner instead."
       );
     }
-    const db = new import_better_sqlite3.default(dbPath);
-    _SqliteAgentRunner.initializeSchema(db);
-    this.db = db;
+    this.db = new import_better_sqlite3.default(dbPath);
+    this.initializeSchema();
   }
-  static initializeSchema(db) {
-    db.exec(`
+  initializeSchema() {
+    this.db.exec(`
       CREATE TABLE IF NOT EXISTS agent_runs (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
         thread_id TEXT NOT NULL,
@@ -67,7 +67,7 @@ var SqliteAgentRunner = class _SqliteAgentRunner extends import_runtime.AgentRun
         version INTEGER NOT NULL
       )
     `);
-    db.exec(`
+    this.db.exec(`
       CREATE TABLE IF NOT EXISTS run_state (
         thread_id TEXT PRIMARY KEY,
         is_running INTEGER DEFAULT 0,
@@ -75,143 +75,305 @@ var SqliteAgentRunner = class _SqliteAgentRunner extends import_runtime.AgentRun
         updated_at INTEGER NOT NULL
       )
     `);
-    db.exec(`
+    this.db.exec(`
       CREATE INDEX IF NOT EXISTS idx_thread_id ON agent_runs(thread_id);
       CREATE INDEX IF NOT EXISTS idx_parent_run_id ON agent_runs(parent_run_id);
     `);
-    db.exec(`
+    this.db.exec(`
       CREATE TABLE IF NOT EXISTS schema_version (
         version INTEGER PRIMARY KEY,
         applied_at INTEGER NOT NULL
       )
     `);
-    const currentVersion = db.prepare("SELECT version FROM schema_version ORDER BY version DESC LIMIT 1").get();
+    const currentVersion = this.db.prepare("SELECT version FROM schema_version ORDER BY version DESC LIMIT 1").get();
     if (!currentVersion || currentVersion.version < SCHEMA_VERSION) {
-      db.prepare("INSERT OR REPLACE INTO schema_version (version, applied_at) VALUES (?, ?)").run(SCHEMA_VERSION, Date.now());
+      this.db.prepare("INSERT OR REPLACE INTO schema_version (version, applied_at) VALUES (?, ?)").run(SCHEMA_VERSION, Date.now());
     }
   }
-  // Hooks implementation using SQLite
-  async acquireRun(threadId, runId) {
-    const row = this.db.prepare("SELECT is_running FROM run_state WHERE thread_id = ?").get(threadId);
-    if (row?.is_running === 1) return false;
-    this.db.prepare(
-      "INSERT OR REPLACE INTO run_state (thread_id, is_running, current_run_id, updated_at) VALUES (?, ?, ?, ?)"
-    ).run(threadId, 1, runId, Date.now());
-    return true;
-  }
-  async releaseRun(threadId) {
-    this.db.prepare("INSERT OR REPLACE INTO run_state (thread_id, is_running, current_run_id, updated_at) VALUES (?, 0, NULL, ?)").run(threadId, Date.now());
-  }
-  async isRunningState(threadId) {
-    const row = this.db.prepare("SELECT is_running FROM run_state WHERE thread_id = ?").get(threadId);
-    return row?.is_running === 1;
-  }
-  async listRuns(threadId) {
-    const rows = this.db.prepare(
-      "SELECT run_id, events, created_at FROM agent_runs WHERE thread_id = ? ORDER BY created_at ASC"
-    ).all(threadId);
-    return rows.map((r) => ({ runId: r.run_id, events: JSON.parse(r.events), createdAt: r.created_at }));
-  }
-  async saveRun(threadId, runId, events, input, parentRunId) {
-    const stmt = this.db.prepare(
-      "INSERT INTO agent_runs (thread_id, run_id, parent_run_id, events, input, created_at, version) VALUES (?, ?, ?, ?, ?, ?, ?)"
-    );
+  storeRun(threadId, runId, events, input, parentRunId) {
+    const compactedEvents = (0, import_client.compactEvents)(events);
+    const stmt = this.db.prepare(`
+      INSERT INTO agent_runs (thread_id, run_id, parent_run_id, events, input, created_at, version)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
     stmt.run(
       threadId,
       runId,
       parentRunId ?? null,
-      JSON.stringify(events),
+      JSON.stringify(compactedEvents),
+      // Store only this run's compacted events
       JSON.stringify(input),
       Date.now(),
       SCHEMA_VERSION
     );
   }
-  async pageThreads(params) {
-    const limit = params.limit ?? 20;
-    const offset = params.offset ?? 0;
-    const totalRow = this.db.prepare("SELECT COUNT(DISTINCT thread_id) AS total FROM agent_runs").get();
-    const rows = this.db.prepare(
-      "SELECT thread_id, MAX(created_at) AS last FROM agent_runs GROUP BY thread_id ORDER BY last DESC LIMIT ? OFFSET ?"
-    ).all(limit, offset);
-    return { threadIds: rows.map((r) => r.thread_id), total: totalRow.total };
-  }
-  async deleteThreadStorage(threadId) {
-    this.db.prepare("DELETE FROM agent_runs WHERE thread_id = ?").run(threadId);
-    this.db.prepare("DELETE FROM run_state WHERE thread_id = ?").run(threadId);
-  }
-  ensureChannel(threadId) {
-    let s = this.channels.get(threadId);
-    if (!s || s.closed) {
-      s = new import_rxjs.ReplaySubject(Infinity);
-      this.channels.set(threadId, s);
-    }
-    return s;
-  }
-  publishLive(threadId, event) {
-    if (event.type === "RUN_STARTED") {
-      const s = new import_rxjs.ReplaySubject(Infinity);
-      this.channels.set(threadId, s);
-    }
-    this.ensureChannel(threadId).next(event);
+  getHistoricRuns(threadId) {
+    const stmt = this.db.prepare(`
+      WITH RECURSIVE run_chain AS (
+        -- Base case: find the root runs (those without parent)
+        SELECT * FROM agent_runs 
+        WHERE thread_id = ? AND parent_run_id IS NULL
+        
+        UNION ALL
+        
+        -- Recursive case: find children of current level
+        SELECT ar.* FROM agent_runs ar
+        INNER JOIN run_chain rc ON ar.parent_run_id = rc.run_id
+        WHERE ar.thread_id = ?
+      )
+      SELECT * FROM run_chain
+      ORDER BY created_at ASC
+    `);
+    const rows = stmt.all(threadId, threadId);
+    return rows.map((row) => ({
+      id: row.id,
+      thread_id: row.thread_id,
+      run_id: row.run_id,
+      parent_run_id: row.parent_run_id,
+      events: JSON.parse(row.events),
+      input: JSON.parse(row.input),
+      created_at: row.created_at,
+      version: row.version
+    }));
   }
-  completeLive(threadId) {
-    const s = this.ensureChannel(threadId);
-    if (!s.closed) s.complete();
+  getLatestRunId(threadId) {
+    const stmt = this.db.prepare(`
+      SELECT run_id FROM agent_runs 
+      WHERE thread_id = ? 
+      ORDER BY created_at DESC 
+      LIMIT 1
+    `);
+    const result = stmt.get(threadId);
+    return result?.run_id ?? null;
   }
-  subscribeLive(threadId) {
-    return this.ensureChannel(threadId).asObservable();
+  setRunState(threadId, isRunning, runId) {
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO run_state (thread_id, is_running, current_run_id, updated_at)
+      VALUES (?, ?, ?, ?)
+    `);
+    stmt.run(threadId, isRunning ? 1 : 0, runId ?? null, Date.now());
   }
-  async closeLive(threadId) {
-    const s = this.channels.get(threadId);
-    if (s && !s.closed) s.complete();
-    this.channels.delete(threadId);
+  getRunState(threadId) {
+    const stmt = this.db.prepare(`
+      SELECT is_running, current_run_id FROM run_state WHERE thread_id = ?
+    `);
+    const result = stmt.get(threadId);
+    return {
+      isRunning: result?.is_running === 1,
+      currentRunId: result?.current_run_id ?? null
+    };
   }
-  // Override connect to preserve original sqlite-runner ordering without re-compacting across runs
-  connect(request) {
-    const { threadId } = request;
-    const subject = new import_rxjs.ReplaySubject(Infinity);
-    void (async () => {
-      const runs = await this.listRuns(threadId);
-      const emittedMessageIds = /* @__PURE__ */ new Set();
-      for (const r of runs) {
-        for (const e of r.events) {
-          subject.next(e);
-          const id = e.messageId;
-          if (typeof id === "string") emittedMessageIds.add(id);
+  run(request) {
+    const runState = this.getRunState(request.threadId);
+    if (runState.isRunning) {
+      throw new Error("Thread already running");
+    }
+    this.setRunState(request.threadId, true, request.input.runId);
+    const seenMessageIds = /* @__PURE__ */ new Set();
+    const currentRunEvents = [];
+    const historicRuns = this.getHistoricRuns(request.threadId);
+    const historicMessageIds = /* @__PURE__ */ new Set();
+    for (const run of historicRuns) {
+      for (const event of run.events) {
+        if ("messageId" in event && typeof event.messageId === "string") {
+          historicMessageIds.add(event.messageId);
+        }
+        if (event.type === import_client.EventType.RUN_STARTED) {
+          const runStarted = event;
+          const messages = runStarted.input?.messages ?? [];
+          for (const message of messages) {
+            historicMessageIds.add(message.id);
+          }
         }
       }
-      const running = await this.isRunningState(threadId);
-      if (!running) {
-        subject.complete();
-        return;
-      }
-      const live$ = this.subscribeLive(threadId);
-      let completed = false;
-      live$.subscribe({
-        next: (e) => {
-          const id = e.messageId;
-          if (typeof id === "string" && emittedMessageIds.has(id)) return;
-          subject.next(e);
-          if (e.type === "RUN_FINISHED" || e.type === "RUN_ERROR") {
-            if (!completed) {
-              completed = true;
-              subject.complete();
+    }
+    const nextSubject = new import_rxjs.ReplaySubject(Infinity);
+    const prevConnection = ACTIVE_CONNECTIONS.get(request.threadId);
+    const prevSubject = prevConnection?.subject;
+    const runSubject = new import_rxjs.ReplaySubject(Infinity);
+    ACTIVE_CONNECTIONS.set(request.threadId, {
+      subject: nextSubject,
+      agent: request.agent,
+      runSubject,
+      currentEvents: currentRunEvents,
+      stopRequested: false
+    });
+    const runAgent = async () => {
+      const parentRunId = this.getLatestRunId(request.threadId);
+      try {
+        await request.agent.runAgent(request.input, {
+          onEvent: ({ event }) => {
+            let processedEvent = event;
+            if (event.type === import_client.EventType.RUN_STARTED) {
+              const runStartedEvent = event;
+              if (!runStartedEvent.input) {
+                const sanitizedMessages = request.input.messages ? request.input.messages.filter(
+                  (message) => !historicMessageIds.has(message.id)
+                ) : void 0;
+                const updatedInput = {
+                  ...request.input,
+                  ...sanitizedMessages !== void 0 ? { messages: sanitizedMessages } : {}
+                };
+                processedEvent = {
+                  ...runStartedEvent,
+                  input: updatedInput
+                };
+              }
+            }
+            runSubject.next(processedEvent);
+            nextSubject.next(processedEvent);
+            currentRunEvents.push(processedEvent);
+          },
+          onNewMessage: ({ message }) => {
+            if (!seenMessageIds.has(message.id)) {
+              seenMessageIds.add(message.id);
+            }
+          },
+          onRunStartedEvent: () => {
+            if (request.input.messages) {
+              for (const message of request.input.messages) {
+                if (!seenMessageIds.has(message.id)) {
+                  seenMessageIds.add(message.id);
+                }
+              }
             }
           }
-        },
-        error: (err) => subject.error(err),
+        });
+        const connection = ACTIVE_CONNECTIONS.get(request.threadId);
+        const appendedEvents = (0, import_runtime.finalizeRunEvents)(currentRunEvents, {
+          stopRequested: connection?.stopRequested ?? false
+        });
+        for (const event of appendedEvents) {
+          runSubject.next(event);
+          nextSubject.next(event);
+        }
+        this.storeRun(
+          request.threadId,
+          request.input.runId,
+          currentRunEvents,
+          request.input,
+          parentRunId
+        );
+        this.setRunState(request.threadId, false);
+        if (connection) {
+          connection.agent = void 0;
+          connection.runSubject = void 0;
+          connection.currentEvents = void 0;
+          connection.stopRequested = false;
+        }
+        runSubject.complete();
+        nextSubject.complete();
+        ACTIVE_CONNECTIONS.delete(request.threadId);
+      } catch {
+        const connection = ACTIVE_CONNECTIONS.get(request.threadId);
+        const appendedEvents = (0, import_runtime.finalizeRunEvents)(currentRunEvents, {
+          stopRequested: connection?.stopRequested ?? false
+        });
+        for (const event of appendedEvents) {
+          runSubject.next(event);
+          nextSubject.next(event);
+        }
+        if (currentRunEvents.length > 0) {
+          this.storeRun(
+            request.threadId,
+            request.input.runId,
+            currentRunEvents,
+            request.input,
+            parentRunId
+          );
+        }
+        this.setRunState(request.threadId, false);
+        if (connection) {
+          connection.agent = void 0;
+          connection.runSubject = void 0;
+          connection.currentEvents = void 0;
+          connection.stopRequested = false;
+        }
+        runSubject.complete();
+        nextSubject.complete();
+        ACTIVE_CONNECTIONS.delete(request.threadId);
+      }
+    };
+    if (prevSubject) {
+      prevSubject.subscribe({
+        next: (e) => nextSubject.next(e),
+        error: (err) => nextSubject.error(err),
         complete: () => {
-          if (!completed) {
-            completed = true;
-            subject.complete();
-          }
         }
       });
-    })();
-    return subject.asObservable();
+    }
+    runAgent();
+    return runSubject.asObservable();
   }
+  connect(request) {
+    const connectionSubject = new import_rxjs.ReplaySubject(Infinity);
+    const historicRuns = this.getHistoricRuns(request.threadId);
+    const allHistoricEvents = [];
+    for (const run of historicRuns) {
+      allHistoricEvents.push(...run.events);
+    }
+    const compactedEvents = (0, import_client.compactEvents)(allHistoricEvents);
+    const emittedMessageIds = /* @__PURE__ */ new Set();
+    for (const event of compactedEvents) {
+      connectionSubject.next(event);
+      if ("messageId" in event && typeof event.messageId === "string") {
+        emittedMessageIds.add(event.messageId);
+      }
+    }
+    const activeConnection = ACTIVE_CONNECTIONS.get(request.threadId);
+    const runState = this.getRunState(request.threadId);
+    if (activeConnection && (runState.isRunning || activeConnection.stopRequested)) {
+      activeConnection.subject.subscribe({
+        next: (event) => {
+          if ("messageId" in event && typeof event.messageId === "string" && emittedMessageIds.has(event.messageId)) {
+            return;
+          }
+          connectionSubject.next(event);
+        },
+        complete: () => connectionSubject.complete(),
+        error: (err) => connectionSubject.error(err)
+      });
+    } else {
+      connectionSubject.complete();
+    }
+    return connectionSubject.asObservable();
+  }
+  isRunning(request) {
+    const runState = this.getRunState(request.threadId);
+    return Promise.resolve(runState.isRunning);
+  }
+  stop(request) {
+    const runState = this.getRunState(request.threadId);
+    if (!runState.isRunning) {
+      return Promise.resolve(false);
+    }
+    const connection = ACTIVE_CONNECTIONS.get(request.threadId);
+    const agent = connection?.agent;
+    if (!connection || !agent) {
+      return Promise.resolve(false);
+    }
+    if (connection.stopRequested) {
+      return Promise.resolve(false);
+    }
+    connection.stopRequested = true;
+    this.setRunState(request.threadId, false);
+    try {
+      agent.abortRun();
+      return Promise.resolve(true);
+    } catch (error) {
+      console.error("Failed to abort sqlite agent run", error);
+      connection.stopRequested = false;
+      this.setRunState(request.threadId, true);
+      return Promise.resolve(false);
+    }
+  }
+  /**
+   * Close the database connection (for cleanup)
+   */
   close() {
-    if (this.db) this.db.close();
+    if (this.db) {
+      this.db.close();
+    }
   }
 };
 // Annotate the CommonJS export names for ESM import in node: