@itmetsam/samurai-framework 0.1.0 → 0.2.0

package/src/script/preload.browser-test.ts

@@ -1,144 +0,0 @@
-import assert from "node:assert/strict";
-import { after, before, test } from "node:test";
-import { Browser } from "../browser/browser.js";
-import type Page from "../browser/page.js";
-import { setContent } from "../testing/browser-fixture.js";
-import type { BiDiConnector } from "../transport/bidi-connection.js";
-import { callFunction } from "./call-function.js";
-import { HELPER_SANDBOX } from "./helpers.js";
-
-let browser: Browser;
-let page: Page;
-let connector: BiDiConnector;
-/** Commands sent to the browser, by method, to count registrations */
-const sentMethods: string[] = [];
-
-before(async () => {
-  ({ browser, page } = await Browser.launch("firefox", { port: 9234, headless: true }));
-  connector = (page as unknown as { biDiConnector: BiDiConnector }).biDiConnector;
-  const send = connector.send.bind(connector);
-  connector.send = ((method: string, params: never, options: never) => {
-    sentMethods.push(method);
-    return send(method as never, params, options);
-  }) as typeof connector.send;
-  await page.navigateTo("about:blank", "complete");
-});
-
-after(async () => {
-  await page.dispose();
-  await browser?.close();
-});
-
-const OPTIONS = { timeout: 20000 };
-const evaluate = <T>(fn: string, sandbox?: string) =>
-  callFunction<T>(connector, page.contextId, fn, [], sandbox === undefined ? {} : { sandbox });
-
-test("an init script runs before page scripts of the next document", OPTIONS, async () => {
-  const handle = await page.addInitScript(() => {
-    (globalThis as any).__x = 1;
-  });
-  await page.navigateTo(
-    "data:text/html,<script>window.seenByPage = window.__x</script>",
-    "complete",
-  );
-  assert.equal(await evaluate("() => window.seenByPage"), 1);
-  await handle.dispose();
-});
-
-test("an init script registered after load applies to the current document and the next one", OPTIONS, async () => {
-  await page.navigateTo("about:blank", "complete");
-  const handle = await page.addInitScript(() => {
-    (globalThis as any).__late = "yes";
-  });
-  assert.equal(await evaluate("() => window.__late"), "yes"); // current document, via the immediate run
-  await page.navigateTo("about:blank?again", "complete");
-  assert.equal(await evaluate("() => window.__late"), "yes"); // next document, via the registration
-  await handle.dispose();
-});
-
-test("an init script receives its argument", OPTIONS, async () => {
-  const handle = await page.addInitScript(
-    (flags: { beta: boolean; name: string }) => {
-      (globalThis as any).__flags = flags;
-    },
-    { beta: true, name: `q"uote 'x' \\` },
-  );
-  await page.navigateTo("about:blank?args", "complete");
-  assert.deepEqual(await evaluate("() => window.__flags"), { beta: true, name: `q"uote 'x' \\` });
-  await handle.dispose();
-});
-
-test("a string init script runs as statements", OPTIONS, async () => {
-  const handle = await page.addInitScript(`window.__a = 1; window.__b = window.__a + 1;`);
-  await page.navigateTo("about:blank?string", "complete");
-  assert.equal(await evaluate("() => window.__b"), 2);
-  await handle.dispose();
-});
-
-test("dispose stops the effect on the next navigation", OPTIONS, async () => {
-  const handle = await page.addInitScript(() => {
-    (globalThis as any).__gone = true;
-  });
-  await page.navigateTo("about:blank?with", "complete");
-  assert.equal(await evaluate("() => window.__gone"), true);
-  await handle.dispose();
-  await page.navigateTo("about:blank?without", "complete");
-  assert.equal(await evaluate("() => window.__gone"), undefined);
-});
-
-test("an init script also applies to iframes", OPTIONS, async () => {
-  const handle = await page.addInitScript(() => {
-    (globalThis as any).__inFrame = "yes";
-  });
-  await page.navigateTo("about:blank?frames", "complete");
-  const seen = await callFunction<Promise<unknown>>(
-    connector,
-    page.contextId,
-    `async () => {
-      const frame = document.body.appendChild(document.createElement("iframe"));
-      frame.src = "about:blank";
-      await new Promise((resolve) => frame.addEventListener("load", resolve, { once: true }));
-      return frame.contentWindow.__inFrame;
-    }`,
-  );
-  assert.equal(seen, "yes");
-  await handle.dispose();
-});
-
-test("a throwing init script does not break registration or the page", OPTIONS, async () => {
-  const handle = await page.addInitScript(`throw new Error("init script boom");`);
-  await page.navigateTo("about:blank?boom", "complete");
-  assert.equal(await evaluate("() => 1 + 1"), 2);
-  await handle.dispose();
-});
-
-test("the helper realm is registered once and invisible to the page", OPTIONS, async () => {
-  await page.navigateTo("about:blank?helpers", "complete");
-  await setContent(page, `<button id="b">Go</button>`);
-  const button = page.locator("button[@id='b']");
-  assert.equal(await button.isEnabled(), true);
-
-  // not on the page's own window ...
-  assert.equal(await evaluate("() => typeof window.__samurai"), "undefined");
-  // ... only in the sandbox realm
-  assert.equal(await evaluate("() => typeof globalThis.__samurai", HELPER_SANDBOX), "object");
-
-  const registrations = () =>
-    sentMethods.filter((method) => method === "script.addPreloadScript").length;
-  const before = registrations();
-  // more probes, after navigations: the registration is reused, and the helpers are there in each new document
-  for (const url of ["about:blank?one", "about:blank?two"]) {
-    await page.navigateTo(url, "complete");
-    await setContent(page, `<button id="b">Go</button>`);
-    assert.equal(await page.locator("button[@id='b']").isEnabled(), true);
-  }
-  assert.equal(registrations(), before);
-});
-
-test("page scripts cannot tamper with the helpers", OPTIONS, async () => {
-  await page.navigateTo("about:blank?tamper", "complete");
-  await setContent(page, `<button id="b">Go</button>`);
-  await evaluate("() => { window.__samurai = { probeElement: () => 'hacked' }; }");
-  const state = await page.locator("button[@id='b']").isEnabled();
-  assert.equal(state, true);
-});

package/src/script/preload.test.ts

@@ -1,180 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { autoReply, FakeWebSocket } from "../testing/fake-websocket.js";
-import { BiDiConnector } from "../transport/bidi-connection.js";
-import { addPreload } from "./preload.js";
-import { ScriptError } from "./call-function.js";
-
-const ok = { type: "success", realm: "r", result: { type: "undefined" } };
-const frame = (context: string, children: object[] = []) => ({ context, parent: null, children });
-
-interface Setup {
-  tree?: (params: any) => object[];
-  callFunction?: (params: any) => object | Error;
-  removePreload?: () => object | Error;
-}
-
-function setup({ tree, callFunction, removePreload }: Setup = {}) {
-  const ws = new FakeWebSocket();
-  const connector = new BiDiConnector(ws as unknown as WebSocket);
-  const stop = autoReply(ws, {
-    "script.addPreloadScript": () => ({ script: "preload-1" }),
-    "browsingContext.getTree": (params) => ({ contexts: tree?.(params) ?? [] }),
-    "script.callFunction": callFunction ?? (() => ok),
-    "script.removePreloadScript": removePreload ?? (() => ({})),
-  });
-  const methods = () => ws.sent.map((m) => m.method);
-  return { ws, connector, stop, methods };
-}
-
-describe("addPreload", () => {
-  it("registers the script with its contexts and sandbox", async () => {
-    const { ws, connector, stop } = setup();
-    const handle = await addPreload(connector, {
-      source: "() => { globalThis.x = 1 }",
-      contexts: ["top"],
-      sandbox: "samurai",
-    });
-    assert.equal(handle.id, "preload-1");
-    assert.deepEqual(ws.sent[0]!.params, {
-      functionDeclaration: "() => { globalThis.x = 1 }",
-      contexts: ["top"],
-      sandbox: "samurai",
-    });
-    stop();
-  });
-
-  it("omits contexts and sandbox when not given", async () => {
-    const { ws, connector, stop } = setup();
-    await addPreload(connector, { source: "() => {}" });
-    assert.deepEqual(ws.sent[0]!.params, { functionDeclaration: "() => {}" });
-    stop();
-  });
-
-  it("also runs the source in every loaded context under the given roots, same sandbox", async () => {
-    const { ws, connector, stop, methods } = setup({
-      tree: (params) =>
-        params.root === "top" ? [frame("top", [frame("child", [frame("grandchild")])])] : [],
-    });
-    await addPreload(connector, { source: "() => 1", contexts: ["top"], sandbox: "samurai" });
-    // registered first, so a document created meanwhile is not missed
-    assert.equal(methods()[0], "script.addPreloadScript");
-    const getTrees = ws.sent.filter((m) => m.method === "browsingContext.getTree");
-    assert.deepEqual(getTrees.map((m) => m.params), [{ root: "top" }]);
-    const calls = ws.sent.filter((m) => m.method === "script.callFunction").map((m) => m.params as any);
-    assert.deepEqual(calls.map((c) => c.target).sort((a, b) => a.context.localeCompare(b.context)), [
-      { context: "child", sandbox: "samurai" },
-      { context: "grandchild", sandbox: "samurai" },
-      { context: "top", sandbox: "samurai" },
-    ]);
-    assert.ok(calls.every((c) => c.functionDeclaration === "() => 1" && c.awaitPromise === false));
-    stop();
-  });
-
-  it("without contexts it covers every top-level context", async () => {
-    const { ws, connector, stop } = setup({ tree: () => [frame("a"), frame("b", [frame("b-frame")])] });
-    await addPreload(connector, { source: "() => 1" });
-    assert.deepEqual(ws.sent.find((m) => m.method === "browsingContext.getTree")!.params, {});
-    const targets = ws.sent
-      .filter((m) => m.method === "script.callFunction")
-      .map((m) => (m.params as any).target.context)
-      .sort();
-    assert.deepEqual(targets, ["a", "b", "b-frame"]);
-    stop();
-  });
-
-  it("ignores a context that disappeared while running", async () => {
-    const ws = new FakeWebSocket();
-    const connector = new BiDiConnector(ws as unknown as WebSocket);
-    const timer = setInterval(() => {
-      for (const m of ws.sent.splice(0)) {
-        if (m.method === "script.addPreloadScript") ws.reply(m.id, { script: "p" });
-        else if (m.method === "browsingContext.getTree") ws.reply(m.id, { contexts: [frame("top")] });
-        else ws.replyError(m.id, "no such frame", "frame is gone");
-      }
-    }, 1).unref();
-    await assert.doesNotReject(addPreload(connector, { source: "() => 1", contexts: ["top"] }));
-    clearInterval(timer);
-  });
-
-  it("throws a ScriptError from the immediate run by default", async () => {
-    const { connector, stop } = setup({
-      tree: () => [frame("top")],
-      callFunction: () => ({
-        type: "exception",
-        realm: "r",
-        exceptionDetails: { text: "ReferenceError: nope", stackTrace: { callFrames: [] } },
-      }),
-    });
-    await assert.rejects(addPreload(connector, { source: "() => nope" }), ScriptError);
-    stop();
-  });
-
-  it("removes the registration again when the immediate run throws", async () => {
-    const { ws, connector, stop, methods } = setup({
-      tree: () => [frame("top")],
-      callFunction: () => ({
-        type: "exception",
-        realm: "r",
-        exceptionDetails: { text: "boom", stackTrace: { callFrames: [] } },
-      }),
-    });
-    await assert.rejects(addPreload(connector, { source: "() => 1" }), ScriptError);
-    assert.ok(methods().includes("script.removePreloadScript"));
-    assert.deepEqual(
-      ws.sent.find((m) => m.method === "script.removePreloadScript")!.params,
-      { script: "preload-1" },
-    );
-    stop();
-  });
-
-  it("with onRunError log the immediate run's exception does not fail the registration", async () => {
-    const { connector, stop } = setup({
-      tree: () => [frame("top")],
-      callFunction: () => ({
-        type: "exception",
-        realm: "r",
-        exceptionDetails: { text: "boom", stackTrace: { callFrames: [] } },
-      }),
-    });
-    const handle = await addPreload(connector, { source: "() => 1", onRunError: "log" });
-    assert.equal(handle.id, "preload-1");
-    stop();
-  });
-
-  it("rethrows when registering fails", async () => {
-    const ws = new FakeWebSocket();
-    const connector = new BiDiConnector(ws as unknown as WebSocket);
-    const timer = setInterval(() => {
-      for (const m of ws.sent.splice(0)) ws.replyError(m.id, "invalid argument", "bad script");
-    }, 1).unref();
-    await assert.rejects(addPreload(connector, { source: "not a function" }), { code: "invalid argument" });
-    clearInterval(timer);
-  });
-
-  it("dispose removes the registration once, however often it is called", async () => {
-    const { ws, connector, stop } = setup();
-    const handle = await addPreload(connector, { source: "() => 1" });
-    await handle.dispose();
-    await handle.dispose();
-    const removals = ws.sent.filter((m) => m.method === "script.removePreloadScript");
-    assert.equal(removals.length, 1);
-    assert.deepEqual(removals[0]!.params, { script: "preload-1" });
-    stop();
-  });
-
-  it("dispose swallows no such script", async () => {
-    const ws = new FakeWebSocket();
-    const connector = new BiDiConnector(ws as unknown as WebSocket);
-    const timer = setInterval(() => {
-      for (const m of ws.sent.splice(0)) {
-        if (m.method === "script.addPreloadScript") ws.reply(m.id, { script: "p" });
-        else if (m.method === "browsingContext.getTree") ws.reply(m.id, { contexts: [] });
-        else ws.replyError(m.id, "no such script", "already removed");
-      }
-    }, 1).unref();
-    const handle = await addPreload(connector, { source: "() => 1" });
-    await assert.doesNotReject(handle.dispose());
-    clearInterval(timer);
-  });
-});

package/src/script/preload.ts

@@ -1,102 +0,0 @@
-import logger from "../logger/index.js";
-import type { BiDiConnector } from "../transport/bidi-connection.js";
-import { BiDiError } from "../transport/bidi-error.js";
-import type { Info } from "../types/bidi-modules/browsing-context.js";
-import { callFunction, ScriptError } from "./call-function.js";
-
-export interface PreloadHandle {
-  readonly id: string;
-  /** Idempotent. Documents that are already loaded keep the effect until they navigate */
-  dispose(): Promise<void>;
-}
-
-export interface RunOptions {
-  /** A function declaration, e.g. `() => { … }` */
-  source: string;
-  /** Top-level contexts to cover, including their iframes. Default: every top-level context */
-  contexts?: string[];
-  /** Named sandbox realm; without it the script runs in the page's own realm */
-  sandbox?: string;
-  /**
-   * What to do when the immediate run in an already-loaded document throws.
-   * "log" suits user init scripts (the browser reports such errors for later documents itself)
-   * @default "throw"
-   */
-  onRunError?: "throw" | "log";
-}
-
-/**
- * Registers `source` to run before any page script in every future document of `contexts`, and
- * also runs it once in the documents that are loaded now: preload scripts only affect documents
- * created after registration, and callers should not have to care about that ordering.
- */
-export async function addPreload(
-  connector: BiDiConnector,
-  options: RunOptions,
-): Promise<PreloadHandle> {
-  const { script } = await connector.send("script.addPreloadScript", {
-    functionDeclaration: options.source,
-    ...(options.contexts && { contexts: options.contexts }),
-    ...(options.sandbox !== undefined && { sandbox: options.sandbox }),
-  });
-
-  let removed = false;
-  const dispose = async () => {
-    if (removed) return;
-    removed = true;
-    try {
-      await connector.send("script.removePreloadScript", { script });
-    } catch (err) {
-      if (err instanceof BiDiError && err.code === "no such script") return;
-      throw err;
-    }
-  };
-
-  try {
-    // Registered first, so a document created while this runs is covered by the registration
-    await runInLoadedContexts(connector, options);
-  } catch (err) {
-    await dispose().catch((disposeErr) =>
-      logger.debug("Could not remove preload script after a failed run", { disposeErr }),
-    );
-    throw err;
-  }
-  return { id: script, dispose };
-}
-
-/** Runs `source` once in every loaded context (iframes included) under `contexts` */
-export async function runInLoadedContexts(
-  connector: BiDiConnector,
-  { source, contexts, sandbox, onRunError = "throw" }: RunOptions,
-): Promise<void> {
-  const trees = contexts
-    ? await Promise.all(
-        contexts.map((root) => connector.send("browsingContext.getTree", { root })),
-      )
-    : [await connector.send("browsingContext.getTree", {})];
-  const loaded = trees.flatMap((tree) => tree.contexts.flatMap(flatten));
-
-  const outcomes = await Promise.allSettled(
-    loaded.map((context) =>
-      callFunction(connector, context, source, [], {
-        awaitPromise: false,
-        ...(sandbox !== undefined && { sandbox }),
-      }),
-    ),
-  );
-  for (const outcome of outcomes) {
-    if (outcome.status === "fulfilled") continue;
-    const err: unknown = outcome.reason;
-    // The context closed between listing and running: nothing left to cover
-    if (err instanceof BiDiError && err.code === "no such frame") continue;
-    if (err instanceof ScriptError && onRunError === "log") {
-      logger.warn("Script threw while running in a loaded document: %s", err.text);
-      continue;
-    }
-    throw err;
-  }
-}
-
-function flatten(info: Info): string[] {
-  return [info.context, ...(info.children ?? []).flatMap(flatten)];
-}

package/src/script/serialize.test.ts

@@ -1,182 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import type { RemoteValue } from "../types/bidi-modules/script.js";
-import { ElementHandle } from "./element-handle.js";
-import { fromRemoteValue, RemoteObject, toLocalValue } from "./serialize.js";
-
-describe("toLocalValue", () => {
-  it("serializes primitives", () => {
-    assert.deepEqual(toLocalValue(undefined), { type: "undefined" });
-    assert.deepEqual(toLocalValue(null), { type: "null" });
-    assert.deepEqual(toLocalValue(true), { type: "boolean", value: true });
-    assert.deepEqual(toLocalValue("a\"b'c\\d\n"), { type: "string", value: "a\"b'c\\d\n" });
-    assert.deepEqual(toLocalValue(12.5), { type: "number", value: 12.5 });
-    assert.deepEqual(toLocalValue(10n), { type: "bigint", value: "10" });
-  });
-
-  it("serializes the special numbers", () => {
-    assert.deepEqual(toLocalValue(NaN), { type: "number", value: "NaN" });
-    assert.deepEqual(toLocalValue(Infinity), { type: "number", value: "Infinity" });
-    assert.deepEqual(toLocalValue(-Infinity), { type: "number", value: "-Infinity" });
-    assert.deepEqual(toLocalValue(-0), { type: "number", value: "-0" });
-    assert.deepEqual(toLocalValue(0), { type: "number", value: 0 });
-  });
-
-  it("serializes dates and regular expressions", () => {
-    assert.deepEqual(toLocalValue(new Date("2026-09-29T10:00:00.000Z")), {
-      type: "date",
-      value: "2026-09-29T10:00:00.000Z",
-    });
-    assert.deepEqual(toLocalValue(/ab+c/gi), { type: "regexp", value: { pattern: "ab+c", flags: "gi" } });
-  });
-
-  it("serializes arrays, sets, maps and plain objects, nested", () => {
-    assert.deepEqual(toLocalValue([1, "a"]), {
-      type: "array",
-      value: [
-        { type: "number", value: 1 },
-        { type: "string", value: "a" },
-      ],
-    });
-    assert.deepEqual(toLocalValue(new Set([1])), { type: "set", value: [{ type: "number", value: 1 }] });
-    assert.deepEqual(toLocalValue(new Map<unknown, unknown>([["k", true], [2, null]])), {
-      type: "map",
-      value: [
-        ["k", { type: "boolean", value: true }],
-        [{ type: "number", value: 2 }, { type: "null" }],
-      ],
-    });
-    assert.deepEqual(toLocalValue({ a: { b: [undefined] } }), {
-      type: "object",
-      value: [
-        [
-          "a",
-          {
-            type: "object",
-            value: [["b", { type: "array", value: [{ type: "undefined" }] }]],
-          },
-        ],
-      ],
-    });
-    assert.deepEqual(toLocalValue(Object.create(null)), { type: "object", value: [] });
-  });
-
-  it("serializes an ElementHandle as a shared reference", () => {
-    assert.deepEqual(toLocalValue(new ElementHandle("node-1")), { sharedId: "node-1" });
-    assert.deepEqual(toLocalValue(new ElementHandle("node-1", "h1")), { sharedId: "node-1", handle: "h1" });
-  });
-
-  it("rejects what cannot cross the wire", () => {
-    assert.throws(() => toLocalValue(() => 1), /cannot serialize function/);
-    assert.throws(() => toLocalValue(Symbol("s")), /cannot serialize symbol/);
-    assert.throws(() => toLocalValue(new (class Foo {})()), /cannot serialize Foo/);
-    assert.throws(() => toLocalValue(Buffer.from("a")), /cannot serialize Buffer/);
-    assert.throws(() => toLocalValue({ nested: () => 1 }), /cannot serialize function/);
-  });
-
-  it("rejects cycles and absurd depth", () => {
-    const loop: Record<string, unknown> = {};
-    loop.self = loop;
-    assert.throws(() => toLocalValue(loop), /circular/);
-    const list: unknown[] = [];
-    list.push(list);
-    assert.throws(() => toLocalValue(list), /circular/);
-    let deep: unknown = 1;
-    for (let i = 0; i < 150; i++) deep = [deep];
-    assert.throws(() => toLocalValue(deep), /too deeply nested/);
-  });
-
-  it("allows the same object twice when it is not a cycle", () => {
-    const shared = { a: 1 };
-    assert.doesNotThrow(() => toLocalValue([shared, shared]));
-  });
-});
-
-describe("fromRemoteValue", () => {
-  it("deserializes primitives and special numbers", () => {
-    assert.equal(fromRemoteValue({ type: "undefined" }), undefined);
-    assert.equal(fromRemoteValue({ type: "null" }), null);
-    assert.equal(fromRemoteValue({ type: "string", value: "x" }), "x");
-    assert.equal(fromRemoteValue({ type: "boolean", value: false }), false);
-    assert.equal(fromRemoteValue({ type: "number", value: 3 }), 3);
-    assert.ok(Number.isNaN(fromRemoteValue({ type: "number", value: "NaN" } as never)));
-    assert.equal(fromRemoteValue({ type: "number", value: "Infinity" } as never), Infinity);
-    assert.equal(fromRemoteValue({ type: "number", value: "-Infinity" } as never), -Infinity);
-    assert.ok(Object.is(fromRemoteValue({ type: "number", value: "-0" } as never), -0));
-    assert.equal(fromRemoteValue({ type: "bigint", value: "12345678901234567890" } as never), 12345678901234567890n);
-  });
-
-  it("deserializes dates and regular expressions", () => {
-    const date = fromRemoteValue({ type: "date", value: "2026-09-29T10:00:00.000Z" }) as Date;
-    assert.equal(date.toISOString(), "2026-09-29T10:00:00.000Z");
-    const regexp = fromRemoteValue({ type: "regexp", value: { pattern: "a+", flags: "i" } } as never) as RegExp;
-    assert.equal(regexp.source, "a+");
-    assert.equal(regexp.flags, "i");
-  });
-
-  it("deserializes collections, nested", () => {
-    const value: RemoteValue = {
-      type: "object",
-      value: [
-        ["list", { type: "array", value: [{ type: "number", value: 1 }, { type: "string", value: "a" }] }],
-        [{ type: "number", value: 5 }, { type: "null" }],
-        ["set", { type: "set", value: [{ type: "boolean", value: true }] } as never],
-        ["map", { type: "map", value: [["k", { type: "number", value: 2 }]] } as never],
-      ],
-    };
-    const result = fromRemoteValue(value) as Record<string, unknown>;
-    assert.deepEqual(result.list, [1, "a"]);
-    assert.equal(result["5"], null);
-    assert.deepEqual([...(result.set as Set<unknown>)], [true]);
-    assert.deepEqual([...(result.map as Map<unknown, unknown>)], [["k", 2]]);
-  });
-
-  it("turns a node into an ElementHandle", () => {
-    const handle = fromRemoteValue({ type: "node", sharedId: "n1", handle: "h1", value: {} } as never);
-    assert.ok(handle instanceof ElementHandle);
-    assert.equal(handle.sharedId, "n1");
-    assert.equal(handle.handle, "h1");
-  });
-
-  it("returns an opaque RemoteObject for values that cannot be copied", () => {
-    for (const type of ["function", "window", "promise", "symbol", "error", "weakmap"]) {
-      const value = fromRemoteValue({ type, handle: "h" } as never);
-      assert.ok(value instanceof RemoteObject, type);
-      assert.equal((value as RemoteObject).type, type);
-      assert.equal((value as RemoteObject).handle, "h");
-    }
-  });
-
-  it("returns a RemoteObject for an object cut off by the serialization depth", () => {
-    const value = fromRemoteValue({ type: "object", handle: "h" } as never);
-    assert.ok(value instanceof RemoteObject);
-  });
-
-  it("resolves internalId back references, cycles included", () => {
-    const value = {
-      type: "object",
-      internalId: "1",
-      value: [["self", { type: "object", internalId: "1" }]],
-    } as RemoteValue;
-    const result = fromRemoteValue(value) as { self: unknown };
-    assert.equal(result.self, result);
-  });
-
-  it("keeps handles when asked, attaching the deserialized value", () => {
-    const value = { type: "object", handle: "h", value: [["a", { type: "number", value: 1 }]] } as RemoteValue;
-    const kept = fromRemoteValue(value, { keepHandles: true }) as RemoteObject;
-    assert.ok(kept instanceof RemoteObject);
-    assert.equal(kept.handle, "h");
-    assert.deepEqual(kept.value, { a: 1 });
-    assert.deepEqual(fromRemoteValue(value), { a: 1 });
-  });
-});
-
-describe("round trip", () => {
-  it("survives toLocalValue → fromRemoteValue for plain data", () => {
-    const data = { a: [1, "two", { three: true }], n: null, d: new Date(0), big: 5n };
-    // A local value has the same shape a remote value has for these types, except `value` keys
-    const remote = toLocalValue(data) as unknown as RemoteValue;
-    assert.deepEqual(fromRemoteValue(remote), data);
-  });
-});