@ricsam/isolate-console 0.0.1 → 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,9 @@
+# @ricsam/isolate-console
+
+## 0.1.1
+
+### Patch Changes
+
+- initial release
+- Updated dependencies
+  - @ricsam/isolate-core@0.1.1

package/package.json

@@ -1,10 +1,29 @@
 {
   "name": "@ricsam/isolate-console",
-  "version": "0.0.1",
-  "description": "OIDC trusted publishing setup package for @ricsam/isolate-console",
-  "keywords": [
-    "oidc",
-    "trusted-publishing",
-    "setup"
-  ]
+  "version": "0.1.1",
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": {
+      "import": "./src/index.ts",
+      "types": "./src/index.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "node --test --experimental-strip-types 'src/**/*.test.ts'",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@ricsam/isolate-core": "*",
+    "isolated-vm": "^6"
+  },
+  "devDependencies": {
+    "@types/node": "^24",
+    "typescript": "^5"
+  },
+  "peerDependencies": {
+    "isolated-vm": "^6"
+  }
 }

package/src/index.ts

@@ -0,0 +1,215 @@
+import ivm from "isolated-vm";
+
+export interface ConsoleOptions {
+  onLog?: (level: string, ...args: unknown[]) => void;
+  onTime?: (label: string, duration: number) => void;
+  onTimeLog?: (label: string, duration: number, ...args: unknown[]) => void;
+  onCount?: (label: string, count: number) => void;
+  onCountReset?: (label: string) => void;
+  onGroup?: (label: string, collapsed: boolean) => void;
+  onGroupEnd?: () => void;
+  onClear?: () => void;
+  onAssert?: (condition: boolean, ...args: unknown[]) => void;
+}
+
+export interface ConsoleHandle {
+  dispose(): void;
+  reset(): void;
+  getTimers(): Map<string, number>;
+  getCounters(): Map<string, number>;
+  getGroupDepth(): number;
+}
+
+/**
+ * Setup console API in an isolated-vm context
+ *
+ * Injects console.log, console.warn, console.error, console.info, console.debug,
+ * console.trace, console.dir, console.table, console.time, console.timeEnd,
+ * console.timeLog, console.count, console.countReset, console.group,
+ * console.groupCollapsed, console.groupEnd, console.clear, console.assert
+ *
+ * @example
+ * const handle = await setupConsole(context, {
+ *   onLog: (level, ...args) => console.log(`[${level}]`, ...args)
+ * });
+ */
+export async function setupConsole(
+  context: ivm.Context,
+  options?: ConsoleOptions
+): Promise<ConsoleHandle> {
+  const opts = options ?? {};
+
+  // State management
+  const timers = new Map<string, number>();
+  const counters = new Map<string, number>();
+  let groupDepth = 0;
+
+  const global = context.global;
+
+  // Log-level methods
+  const logLevels = [
+    "log",
+    "warn",
+    "error",
+    "debug",
+    "info",
+    "trace",
+    "dir",
+    "table",
+  ];
+
+  for (const level of logLevels) {
+    global.setSync(
+      `__console_${level}`,
+      new ivm.Callback((...args: unknown[]) => {
+        opts.onLog?.(level, ...args);
+      })
+    );
+  }
+
+  // Timing methods
+  global.setSync(
+    "__console_time",
+    new ivm.Callback((label?: string) => {
+      const l = label ?? "default";
+      timers.set(l, performance.now());
+    })
+  );
+
+  global.setSync(
+    "__console_timeEnd",
+    new ivm.Callback((label?: string) => {
+      const l = label ?? "default";
+      const start = timers.get(l);
+      if (start !== undefined) {
+        const duration = performance.now() - start;
+        timers.delete(l);
+        opts.onTime?.(l, duration);
+      }
+    })
+  );
+
+  global.setSync(
+    "__console_timeLog",
+    new ivm.Callback((label?: string, ...args: unknown[]) => {
+      const l = label ?? "default";
+      const start = timers.get(l);
+      if (start !== undefined) {
+        const duration = performance.now() - start;
+        opts.onTimeLog?.(l, duration, ...args);
+      }
+    })
+  );
+
+  // Counting methods
+  global.setSync(
+    "__console_count",
+    new ivm.Callback((label?: string) => {
+      const l = label ?? "default";
+      const count = (counters.get(l) ?? 0) + 1;
+      counters.set(l, count);
+      opts.onCount?.(l, count);
+    })
+  );
+
+  global.setSync(
+    "__console_countReset",
+    new ivm.Callback((label?: string) => {
+      const l = label ?? "default";
+      counters.delete(l);
+      opts.onCountReset?.(l);
+    })
+  );
+
+  // Grouping methods
+  global.setSync(
+    "__console_group",
+    new ivm.Callback((label?: string) => {
+      const l = label ?? "default";
+      groupDepth++;
+      opts.onGroup?.(l, false);
+    })
+  );
+
+  global.setSync(
+    "__console_groupCollapsed",
+    new ivm.Callback((label?: string) => {
+      const l = label ?? "default";
+      groupDepth++;
+      opts.onGroup?.(l, true);
+    })
+  );
+
+  global.setSync(
+    "__console_groupEnd",
+    new ivm.Callback(() => {
+      if (groupDepth > 0) {
+        groupDepth--;
+      }
+      opts.onGroupEnd?.();
+    })
+  );
+
+  // Other methods
+  global.setSync(
+    "__console_clear",
+    new ivm.Callback(() => {
+      opts.onClear?.();
+    })
+  );
+
+  global.setSync(
+    "__console_assert",
+    new ivm.Callback((condition: boolean, ...args: unknown[]) => {
+      if (!condition) {
+        opts.onAssert?.(condition, ...args);
+      }
+    })
+  );
+
+  // Inject console object
+  context.evalSync(`
+    globalThis.console = {
+      log: __console_log,
+      warn: __console_warn,
+      error: __console_error,
+      debug: __console_debug,
+      info: __console_info,
+      trace: __console_trace,
+      dir: __console_dir,
+      table: __console_table,
+      time: __console_time,
+      timeEnd: __console_timeEnd,
+      timeLog: __console_timeLog,
+      count: __console_count,
+      countReset: __console_countReset,
+      group: __console_group,
+      groupCollapsed: __console_groupCollapsed,
+      groupEnd: __console_groupEnd,
+      clear: __console_clear,
+      assert: __console_assert,
+    };
+  `);
+
+  return {
+    dispose() {
+      timers.clear();
+      counters.clear();
+      groupDepth = 0;
+    },
+    reset() {
+      timers.clear();
+      counters.clear();
+      groupDepth = 0;
+    },
+    getTimers() {
+      return new Map(timers);
+    },
+    getCounters() {
+      return new Map(counters);
+    },
+    getGroupDepth() {
+      return groupDepth;
+    },
+  };
+}

package/src/setup.test.ts

@@ -0,0 +1,509 @@
+import { test, describe, beforeEach, afterEach } from "node:test";
+import assert from "node:assert";
+import ivm from "isolated-vm";
+import { setupConsole, type ConsoleHandle } from "./index.ts";
+
+describe("@ricsam/isolate-console", () => {
+  let isolate: ivm.Isolate;
+  let context: ivm.Context;
+
+  beforeEach(async () => {
+    isolate = new ivm.Isolate();
+    context = await isolate.createContext();
+  });
+
+  afterEach(() => {
+    context.release();
+    isolate.dispose();
+  });
+
+  describe("log-level methods", () => {
+    test("console.log calls onLog with correct level", async () => {
+      const logCalls: Array<{ level: string; args: unknown[] }> = [];
+      await setupConsole(context, {
+        onLog: (level, ...args) => logCalls.push({ level, args }),
+      });
+      context.evalSync(`console.log("hello", 123)`);
+      assert.strictEqual(logCalls.length, 1);
+      assert.strictEqual(logCalls[0].level, "log");
+      assert.deepStrictEqual(logCalls[0].args, ["hello", 123]);
+    });
+
+    test("console.warn calls onLog with warn level", async () => {
+      const logCalls: Array<{ level: string; args: unknown[] }> = [];
+      await setupConsole(context, {
+        onLog: (level, ...args) => logCalls.push({ level, args }),
+      });
+      context.evalSync(`console.warn("warning")`);
+      assert.strictEqual(logCalls.length, 1);
+      assert.strictEqual(logCalls[0].level, "warn");
+      assert.deepStrictEqual(logCalls[0].args, ["warning"]);
+    });
+
+    test("console.error calls onLog with error level", async () => {
+      const logCalls: Array<{ level: string; args: unknown[] }> = [];
+      await setupConsole(context, {
+        onLog: (level, ...args) => logCalls.push({ level, args }),
+      });
+      context.evalSync(`console.error("error message")`);
+      assert.strictEqual(logCalls.length, 1);
+      assert.strictEqual(logCalls[0].level, "error");
+      assert.deepStrictEqual(logCalls[0].args, ["error message"]);
+    });
+
+    test("console.debug calls onLog with debug level", async () => {
+      const logCalls: Array<{ level: string; args: unknown[] }> = [];
+      await setupConsole(context, {
+        onLog: (level, ...args) => logCalls.push({ level, args }),
+      });
+      context.evalSync(`console.debug("debug info")`);
+      assert.strictEqual(logCalls.length, 1);
+      assert.strictEqual(logCalls[0].level, "debug");
+    });
+
+    test("console.info calls onLog with info level", async () => {
+      const logCalls: Array<{ level: string; args: unknown[] }> = [];
+      await setupConsole(context, {
+        onLog: (level, ...args) => logCalls.push({ level, args }),
+      });
+      context.evalSync(`console.info("information")`);
+      assert.strictEqual(logCalls.length, 1);
+      assert.strictEqual(logCalls[0].level, "info");
+    });
+
+    test("console.trace calls onLog with trace level", async () => {
+      const logCalls: Array<{ level: string; args: unknown[] }> = [];
+      await setupConsole(context, {
+        onLog: (level, ...args) => logCalls.push({ level, args }),
+      });
+      context.evalSync(`console.trace("trace")`);
+      assert.strictEqual(logCalls.length, 1);
+      assert.strictEqual(logCalls[0].level, "trace");
+    });
+
+    test("console.dir calls onLog with dir level", async () => {
+      const logCalls: Array<{ level: string; args: unknown[] }> = [];
+      await setupConsole(context, {
+        onLog: (level, ...args) => logCalls.push({ level, args }),
+      });
+      context.evalSync(`console.dir({ key: "value" })`);
+      assert.strictEqual(logCalls.length, 1);
+      assert.strictEqual(logCalls[0].level, "dir");
+      assert.deepStrictEqual(logCalls[0].args, [{ key: "value" }]);
+    });
+
+    test("console.table calls onLog with table level", async () => {
+      const logCalls: Array<{ level: string; args: unknown[] }> = [];
+      await setupConsole(context, {
+        onLog: (level, ...args) => logCalls.push({ level, args }),
+      });
+      context.evalSync(`console.table([1, 2, 3])`);
+      assert.strictEqual(logCalls.length, 1);
+      assert.strictEqual(logCalls[0].level, "table");
+      assert.deepStrictEqual(logCalls[0].args, [[1, 2, 3]]);
+    });
+
+    test("console.log with no arguments", async () => {
+      const logCalls: Array<{ level: string; args: unknown[] }> = [];
+      await setupConsole(context, {
+        onLog: (level, ...args) => logCalls.push({ level, args }),
+      });
+      context.evalSync(`console.log()`);
+      assert.strictEqual(logCalls.length, 1);
+      assert.deepStrictEqual(logCalls[0].args, []);
+    });
+
+    test("console.log with multiple arguments", async () => {
+      const logCalls: Array<{ level: string; args: unknown[] }> = [];
+      await setupConsole(context, {
+        onLog: (level, ...args) => logCalls.push({ level, args }),
+      });
+      context.evalSync(`console.log("a", "b", "c", 1, 2, 3)`);
+      assert.strictEqual(logCalls.length, 1);
+      assert.deepStrictEqual(logCalls[0].args, ["a", "b", "c", 1, 2, 3]);
+    });
+  });
+
+  describe("timing methods", () => {
+    test("console.time starts a timer", async () => {
+      const handle = await setupConsole(context);
+      context.evalSync(`console.time("test")`);
+      assert.strictEqual(handle.getTimers().has("test"), true);
+    });
+
+    test("console.time uses default label", async () => {
+      const handle = await setupConsole(context);
+      context.evalSync(`console.time()`);
+      assert.strictEqual(handle.getTimers().has("default"), true);
+    });
+
+    test("console.timeEnd reports duration", async () => {
+      const timeCalls: Array<{ label: string; duration: number }> = [];
+      const handle = await setupConsole(context, {
+        onTime: (label, duration) => timeCalls.push({ label, duration }),
+      });
+      context.evalSync(`console.time("test")`);
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      context.evalSync(`console.timeEnd("test")`);
+
+      assert.strictEqual(timeCalls.length, 1);
+      assert.strictEqual(timeCalls[0].label, "test");
+      assert.ok(timeCalls[0].duration >= 0);
+      assert.strictEqual(handle.getTimers().has("test"), false);
+    });
+
+    test("console.timeEnd with default label", async () => {
+      const timeCalls: Array<{ label: string; duration: number }> = [];
+      await setupConsole(context, {
+        onTime: (label, duration) => timeCalls.push({ label, duration }),
+      });
+      context.evalSync(`console.time()`);
+      await new Promise((resolve) => setTimeout(resolve, 5));
+      context.evalSync(`console.timeEnd()`);
+
+      assert.strictEqual(timeCalls.length, 1);
+      assert.strictEqual(timeCalls[0].label, "default");
+    });
+
+    test("console.timeEnd with non-existent timer is no-op", async () => {
+      const timeCalls: Array<{ label: string; duration: number }> = [];
+      await setupConsole(context, {
+        onTime: (label, duration) => timeCalls.push({ label, duration }),
+      });
+      context.evalSync(`console.timeEnd("nonexistent")`);
+      assert.strictEqual(timeCalls.length, 0);
+    });
+
+    test("console.timeLog reports duration without ending", async () => {
+      const timeLogCalls: Array<{
+        label: string;
+        duration: number;
+        args: unknown[];
+      }> = [];
+      const handle = await setupConsole(context, {
+        onTimeLog: (label, duration, ...args) =>
+          timeLogCalls.push({ label, duration, args }),
+      });
+      context.evalSync(`console.time("test")`);
+      await new Promise((resolve) => setTimeout(resolve, 5));
+      context.evalSync(`console.timeLog("test", "additional", "args")`);
+
+      assert.strictEqual(timeLogCalls.length, 1);
+      assert.strictEqual(timeLogCalls[0].label, "test");
+      assert.deepStrictEqual(timeLogCalls[0].args, ["additional", "args"]);
+      assert.strictEqual(handle.getTimers().has("test"), true); // Timer still running
+    });
+
+    test("console.timeLog with non-existent timer is no-op", async () => {
+      const timeLogCalls: Array<{
+        label: string;
+        duration: number;
+        args: unknown[];
+      }> = [];
+      await setupConsole(context, {
+        onTimeLog: (label, duration, ...args) =>
+          timeLogCalls.push({ label, duration, args }),
+      });
+      context.evalSync(`console.timeLog("nonexistent")`);
+      assert.strictEqual(timeLogCalls.length, 0);
+    });
+  });
+
+  describe("counting methods", () => {
+    test("console.count increments counter", async () => {
+      const countCalls: Array<{ label: string; count: number }> = [];
+      await setupConsole(context, {
+        onCount: (label, count) => countCalls.push({ label, count }),
+      });
+      context.evalSync(`console.count("test")`);
+      assert.strictEqual(countCalls.length, 1);
+      assert.deepStrictEqual(countCalls[0], { label: "test", count: 1 });
+
+      context.evalSync(`console.count("test")`);
+      assert.strictEqual(countCalls.length, 2);
+      assert.deepStrictEqual(countCalls[1], { label: "test", count: 2 });
+    });
+
+    test("console.count uses default label", async () => {
+      const countCalls: Array<{ label: string; count: number }> = [];
+      await setupConsole(context, {
+        onCount: (label, count) => countCalls.push({ label, count }),
+      });
+      context.evalSync(`console.count()`);
+      assert.strictEqual(countCalls[0].label, "default");
+    });
+
+    test("console.countReset clears counter", async () => {
+      const countCalls: Array<{ label: string; count: number }> = [];
+      const countResetCalls: string[] = [];
+      const handle = await setupConsole(context, {
+        onCount: (label, count) => countCalls.push({ label, count }),
+        onCountReset: (label) => countResetCalls.push(label),
+      });
+      context.evalSync(`console.count("test")`);
+      context.evalSync(`console.count("test")`);
+      context.evalSync(`console.countReset("test")`);
+
+      assert.deepStrictEqual(countResetCalls, ["test"]);
+      assert.strictEqual(handle.getCounters().has("test"), false);
+
+      // After reset, count starts from 1 again
+      context.evalSync(`console.count("test")`);
+      assert.deepStrictEqual(countCalls[countCalls.length - 1], {
+        label: "test",
+        count: 1,
+      });
+    });
+
+    test("console.countReset with default label", async () => {
+      const countResetCalls: string[] = [];
+      await setupConsole(context, {
+        onCountReset: (label) => countResetCalls.push(label),
+      });
+      context.evalSync(`console.count()`);
+      context.evalSync(`console.countReset()`);
+      assert.deepStrictEqual(countResetCalls, ["default"]);
+    });
+
+    test("console.countReset with non-existent counter still calls handler", async () => {
+      const countResetCalls: string[] = [];
+      await setupConsole(context, {
+        onCountReset: (label) => countResetCalls.push(label),
+      });
+      context.evalSync(`console.countReset("nonexistent")`);
+      assert.deepStrictEqual(countResetCalls, ["nonexistent"]);
+    });
+
+    test("getCounters returns correct state", async () => {
+      const handle = await setupConsole(context);
+      context.evalSync(`console.count("a")`);
+      context.evalSync(`console.count("a")`);
+      context.evalSync(`console.count("b")`);
+
+      const counters = handle.getCounters();
+      assert.strictEqual(counters.get("a"), 2);
+      assert.strictEqual(counters.get("b"), 1);
+    });
+  });
+
+  describe("grouping methods", () => {
+    test("console.group increments depth", async () => {
+      const groupCalls: Array<{ label: string; collapsed: boolean }> = [];
+      const handle = await setupConsole(context, {
+        onGroup: (label, collapsed) => groupCalls.push({ label, collapsed }),
+      });
+      assert.strictEqual(handle.getGroupDepth(), 0);
+      context.evalSync(`console.group("Group 1")`);
+      assert.strictEqual(handle.getGroupDepth(), 1);
+      assert.deepStrictEqual(groupCalls[0], {
+        label: "Group 1",
+        collapsed: false,
+      });
+    });
+
+    test("console.groupCollapsed increments depth with collapsed flag", async () => {
+      const groupCalls: Array<{ label: string; collapsed: boolean }> = [];
+      const handle = await setupConsole(context, {
+        onGroup: (label, collapsed) => groupCalls.push({ label, collapsed }),
+      });
+      context.evalSync(`console.groupCollapsed("Collapsed Group")`);
+      assert.strictEqual(handle.getGroupDepth(), 1);
+      assert.deepStrictEqual(groupCalls[0], {
+        label: "Collapsed Group",
+        collapsed: true,
+      });
+    });
+
+    test("console.group uses default label", async () => {
+      const groupCalls: Array<{ label: string; collapsed: boolean }> = [];
+      await setupConsole(context, {
+        onGroup: (label, collapsed) => groupCalls.push({ label, collapsed }),
+      });
+      context.evalSync(`console.group()`);
+      assert.strictEqual(groupCalls[0].label, "default");
+    });
+
+    test("console.groupEnd decrements depth", async () => {
+      let groupEndCalls = 0;
+      const handle = await setupConsole(context, {
+        onGroupEnd: () => groupEndCalls++,
+      });
+      context.evalSync(`console.group()`);
+      context.evalSync(`console.group()`);
+      assert.strictEqual(handle.getGroupDepth(), 2);
+
+      context.evalSync(`console.groupEnd()`);
+      assert.strictEqual(handle.getGroupDepth(), 1);
+      assert.strictEqual(groupEndCalls, 1);
+    });
+
+    test("console.groupEnd at depth 0 stays at 0", async () => {
+      let groupEndCalls = 0;
+      const handle = await setupConsole(context, {
+        onGroupEnd: () => groupEndCalls++,
+      });
+      context.evalSync(`console.groupEnd()`);
+      assert.strictEqual(handle.getGroupDepth(), 0);
+      assert.strictEqual(groupEndCalls, 1); // Handler still called
+    });
+
+    test("nested groups track depth correctly", async () => {
+      const handle = await setupConsole(context);
+      context.evalSync(`
+        console.group("Level 1");
+        console.group("Level 2");
+        console.group("Level 3");
+      `);
+      assert.strictEqual(handle.getGroupDepth(), 3);
+
+      context.evalSync(`
+        console.groupEnd();
+        console.groupEnd();
+      `);
+      assert.strictEqual(handle.getGroupDepth(), 1);
+    });
+  });
+
+  describe("other methods", () => {
+    test("console.clear calls onClear", async () => {
+      let clearCalls = 0;
+      await setupConsole(context, {
+        onClear: () => clearCalls++,
+      });
+      context.evalSync(`console.clear()`);
+      assert.strictEqual(clearCalls, 1);
+    });
+
+    test("console.assert with truthy condition does not call handler", async () => {
+      const assertCalls: Array<{ condition: boolean; args: unknown[] }> = [];
+      await setupConsole(context, {
+        onAssert: (condition, ...args) =>
+          assertCalls.push({ condition, args }),
+      });
+      context.evalSync(`console.assert(true, "should not appear")`);
+      assert.strictEqual(assertCalls.length, 0);
+    });
+
+    test("console.assert with falsy condition calls handler", async () => {
+      const assertCalls: Array<{ condition: boolean; args: unknown[] }> = [];
+      await setupConsole(context, {
+        onAssert: (condition, ...args) =>
+          assertCalls.push({ condition, args }),
+      });
+      context.evalSync(`console.assert(false, "assertion failed", 123)`);
+      assert.strictEqual(assertCalls.length, 1);
+      assert.deepStrictEqual(assertCalls[0], {
+        condition: false,
+        args: ["assertion failed", 123],
+      });
+    });
+
+    test("console.assert with undefined condition calls handler", async () => {
+      const assertCalls: Array<{ condition: boolean; args: unknown[] }> = [];
+      await setupConsole(context, {
+        onAssert: (condition, ...args) =>
+          assertCalls.push({ condition, args }),
+      });
+      context.evalSync(`console.assert(undefined)`);
+      assert.strictEqual(assertCalls.length, 1);
+    });
+
+    test("console.assert with 0 calls handler", async () => {
+      const assertCalls: Array<{ condition: boolean; args: unknown[] }> = [];
+      await setupConsole(context, {
+        onAssert: (condition, ...args) =>
+          assertCalls.push({ condition, args }),
+      });
+      context.evalSync(`console.assert(0)`);
+      assert.strictEqual(assertCalls.length, 1);
+    });
+
+    test("console.assert with empty string calls handler", async () => {
+      const assertCalls: Array<{ condition: boolean; args: unknown[] }> = [];
+      await setupConsole(context, {
+        onAssert: (condition, ...args) =>
+          assertCalls.push({ condition, args }),
+      });
+      context.evalSync(`console.assert("")`);
+      assert.strictEqual(assertCalls.length, 1);
+    });
+
+    test("console.assert with null calls handler", async () => {
+      const assertCalls: Array<{ condition: boolean; args: unknown[] }> = [];
+      await setupConsole(context, {
+        onAssert: (condition, ...args) =>
+          assertCalls.push({ condition, args }),
+      });
+      context.evalSync(`console.assert(null)`);
+      assert.strictEqual(assertCalls.length, 1);
+    });
+  });
+
+  describe("handle methods", () => {
+    test("reset() clears all state", async () => {
+      const handle = await setupConsole(context);
+      context.evalSync(`
+        console.time("timer");
+        console.count("counter");
+        console.group("group");
+      `);
+
+      assert.strictEqual(handle.getTimers().size, 1);
+      assert.strictEqual(handle.getCounters().size, 1);
+      assert.strictEqual(handle.getGroupDepth(), 1);
+
+      handle.reset();
+
+      assert.strictEqual(handle.getTimers().size, 0);
+      assert.strictEqual(handle.getCounters().size, 0);
+      assert.strictEqual(handle.getGroupDepth(), 0);
+    });
+
+    test("getTimers returns a copy", async () => {
+      const handle = await setupConsole(context);
+      context.evalSync(`console.time("test")`);
+      const timers1 = handle.getTimers();
+      const timers2 = handle.getTimers();
+      assert.notStrictEqual(timers1, timers2);
+      assert.deepStrictEqual([...timers1.keys()], [...timers2.keys()]);
+    });
+
+    test("getCounters returns a copy", async () => {
+      const handle = await setupConsole(context);
+      context.evalSync(`console.count("test")`);
+      const counters1 = handle.getCounters();
+      const counters2 = handle.getCounters();
+      assert.notStrictEqual(counters1, counters2);
+      assert.deepStrictEqual(counters1, counters2);
+    });
+  });
+
+  describe("no handlers", () => {
+    test("works without handlers", async () => {
+      // Create a new context without handlers
+      const testIsolate = new ivm.Isolate();
+      const testContext = await testIsolate.createContext();
+
+      const h = await setupConsole(testContext); // No handlers
+
+      const result = testContext.evalSync(`
+        console.log("test");
+        console.time("t");
+        console.timeEnd("t");
+        console.count("c");
+        console.countReset("c");
+        console.clear();
+        console.assert(false);
+        console.group("g");
+        console.groupEnd();
+        "done"
+      `);
+
+      assert.strictEqual(result, "done");
+
+      h.dispose();
+      testContext.release();
+      testIsolate.dispose();
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}

package/README.md

@@ -1,45 +0,0 @@
-# @ricsam/isolate-console
-
-## ⚠️ IMPORTANT NOTICE ⚠️
-
-**This package is created solely for the purpose of setting up OIDC (OpenID Connect) trusted publishing with npm.**
-
-This is **NOT** a functional package and contains **NO** code or functionality beyond the OIDC setup configuration.
-
-## Purpose
-
-This package exists to:
-1. Configure OIDC trusted publishing for the package name `@ricsam/isolate-console`
-2. Enable secure, token-less publishing from CI/CD workflows
-3. Establish provenance for packages published under this name
-
-## What is OIDC Trusted Publishing?
-
-OIDC trusted publishing allows package maintainers to publish packages directly from their CI/CD workflows without needing to manage npm access tokens. Instead, it uses OpenID Connect to establish trust between the CI/CD provider (like GitHub Actions) and npm.
-
-## Setup Instructions
-
-To properly configure OIDC trusted publishing for this package:
-
-1. Go to [npmjs.com](https://www.npmjs.com/) and navigate to your package settings
-2. Configure the trusted publisher (e.g., GitHub Actions)
-3. Specify the repository and workflow that should be allowed to publish
-4. Use the configured workflow to publish your actual package
-
-## DO NOT USE THIS PACKAGE
-
-This package is a placeholder for OIDC configuration only. It:
-- Contains no executable code
-- Provides no functionality
-- Should not be installed as a dependency
-- Exists only for administrative purposes
-
-## More Information
-
-For more details about npm's trusted publishing feature, see:
-- [npm Trusted Publishing Documentation](https://docs.npmjs.com/generating-provenance-statements)
-- [GitHub Actions OIDC Documentation](https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/about-security-hardening-with-openid-connect)
-
----
-
-**Maintained for OIDC setup purposes only**