Skip to content

Open-source AI coworkers that each get a computer of their own: a browser, files and tools, with every action decided before it happens and recorded after. Bring any AG-UI agent.

4.0 KB
Raw Blame
import { describe, expect, test } from "bun:test";
import { createSequencer, SEQ_RESTART_GAP } from "../src/offscreen/sequencer";

function fakeTimers() {
  let nextId = 1;
  const pending = new Map<number, { fn: () => void; at: number }>();
  let clock = 0;
  return {
    set(fn: () => void, ms: number) {
      const id = nextId++;
      pending.set(id, { fn, at: clock + ms });
      return id;
    },
    clear(handle: unknown) {
      pending.delete(handle as number);
    },
    advance(ms: number) {
      clock += ms;
      for (const [id, t] of [...pending]) {
        if (t.at <= clock) {
          pending.delete(id);
          t.fn();
        }
      }
    },
    get size() {
      return pending.size;
    },
  };
}

function makeDeps(now: () => number, initial: number | null = null) {
  const store: { value: number | null; saves: number[] } = {
    value: initial,
    saves: [],
  };
  const timers = fakeTimers();
  return {
    store,
    timers,
    deps: {
      now,
      load: async () => store.value,
      save: async (v: number) => {
        store.value = v;
        store.saves.push(v);
      },
      timers,
    },
  };
}

describe("sequencer", () => {
  test("events from three frames and a restarted offscreen document never share a seq", async () => {
    let now = 1_000_000;
    const store: { value: number | null } = { value: null };
    const timers = fakeTimers();
    const deps = {
      now: () => now,
      load: async () => store.value,
      save: async (v: number) => {
        store.value = v;
      },
      timers,
    };
    const first = await createSequencer(deps);
    const seen = new Set<number>();
    for (let i = 0; i < 3000; i++) seen.add(first.next());
    timers.advance(250);
    await Promise.resolve();
    for (let i = 0; i < 500; i++) seen.add(first.next());
    now -= 5;
    const second = await createSequencer(deps);
    for (let i = 0; i < 1000; i++) {
      const s = second.next();
      expect(seen.has(s)).toBe(false);
      seen.add(s);
    }
    expect(seen.size).toBe(4500);
  });

  test("a first start begins at now times 1000 and counts up by one", async () => {
    const { deps } = makeDeps(() => 1234);
    const sequencer = await createSequencer(deps);
    expect(sequencer.next()).toBe(1_234_000);
    expect(sequencer.next()).toBe(1_234_001);
  });

  test("a restart starts a full gap above the saved seq when the clock is behind it", async () => {
    const { deps } = makeDeps(() => 1, 9_000_000_000);
    const sequencer = await createSequencer(deps);
    expect(sequencer.next()).toBe(9_000_000_000 + SEQ_RESTART_GAP);
  });

  test("a restart starts at the clock when the clock is far ahead of the saved seq", async () => {
    const { deps } = makeDeps(() => 5_000_000, 10);
    const sequencer = await createSequencer(deps);
    expect(sequencer.next()).toBe(5_000_000_000);
  });

  test("saves the last issued seq once per 250 ms, however many were issued", async () => {
    const { deps, store, timers } = makeDeps(() => 5000);
    const sequencer = await createSequencer(deps);
    for (let i = 0; i < 10; i++) sequencer.next();
    expect(store.saves).toEqual([]);
    timers.advance(249);
    expect(store.saves).toEqual([]);
    timers.advance(1);
    expect(store.saves).toEqual([5_000_009]);
    timers.advance(1000);
    expect(store.saves).toEqual([5_000_009]);
    sequencer.next();
    timers.advance(250);
    expect(store.saves).toEqual([5_000_009, 5_000_010]);
  });

  test("flush saves the last issued seq now and cancels the pending save", async () => {
    const { deps, store, timers } = makeDeps(() => 5000);
    const sequencer = await createSequencer(deps);
    sequencer.next();
    sequencer.next();
    await sequencer.flush();
    expect(store.saves).toEqual([5_000_001]);
    expect(timers.size).toBe(0);
  });

  test("flush with nothing issued saves nothing", async () => {
    const { deps, store } = makeDeps(() => 5000);
    const sequencer = await createSequencer(deps);
    await sequencer.flush();
    expect(store.saves).toEqual([]);
  });
});