Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

53.4 KB
Raw Blame
import { createEffect, createRoot, untrack } from 'solid-js';
import { afterEach, describe, expect, it, vi } from 'vitest';
import { createMemoryHistory } from '../history/memory';
import { createSolidRouterHistory } from '../history/solid-router';
import type { HistoryAdapter } from '../history/types';
import { createMemoryPaneStore } from '../panes/memory-store';
import { createSplitRouter } from '../router/create-router';
import { PANE_LEVEL } from '../router/leave-guards';
import type { SplitCloseAction, SplitRouterOptions } from '../router/types';
import { defineRoute } from '../routes/define';
import type {
  Entry,
  PaneId,
  SplitRouteDefinition,
  SplitRoutes,
} from '../routes/types';
import { isPromise } from '../utils';
import { createFakeSolidRouter } from './fake-solid-router';
import {
  appLocation,
  appRoute,
  appRoutes,
  createTestPolicy,
  homeLocation,
  loginRoute,
} from './fixtures';

function setup(
  url: string,
  overrides: Partial<SplitRouterOptions> = {},
  testPolicy = createTestPolicy()
) {
  const history = createMemoryHistory(url);
  const paneStore = createMemoryPaneStore<Entry>();
  const { policy, activated, placements } = testPolicy;
  let created = 0;
  const { router, dispose } = createRoot((dispose) => ({
    router: createSplitRouter({
      routes: appRoutes,
      history,
      paneStore,
      policy,
      createPaneId: () => `pane-${++created}` as PaneId,
      ...overrides,
    }),
    dispose,
  }));
  return {
    router,
    history,
    paneStore,
    activated,
    placements,
    pane: (index: number) => router.panes()[index]!,
    dispose: () => {
      router.dispose();
      dispose();
    },
  };
}

/** A router over the Solid Router fake mounted at `/app`. */
function setupSolid(url: string, ahead: readonly string[] = []) {
  const solid = createFakeSolidRouter(url, ahead);
  return createRoot((dispose) => {
    const router = createSplitRouter({
      routes: appRoutes,
      history: createSolidRouterHistory({
        location: solid.location,
        navigate: solid.navigate,
        base: '/app',
        beforeLeave: solid.beforeLeave,
        landedPath: solid.landed,
      }),
      paneStore: createMemoryPaneStore(),
      policy: createTestPolicy().policy,
    });
    return {
      router,
      solid,
      dispose: () => {
        router.dispose();
        dispose();
      },
    };
  });
}

/** Memory history whose reverts land only when the test says so. */
function slowRevertHistory(url: string) {
  const history = createMemoryHistory(url);
  const landings: (() => Promise<void>)[] = [];
  const adapter: HistoryAdapter = {
    ...history,
    subscribe: (listener) =>
      history.subscribe((change) =>
        listener({
          ...change,
          revert: () =>
            new Promise<void>((resolve) => {
              landings.push(async () => {
                await change.revert();
                resolve();
              });
            }),
        })
      ),
  };

  const landAll = async () => {
    for (let attempt = 0; attempt < 8; attempt += 1) {
      await landings.shift()?.();
      await new Promise((resolve) => setTimeout(resolve, 0));
    }
  };

  return { history, adapter, landAll };
}

/** The level of a pane's first route, below the app route. */
const PANE_ROUTE_LEVEL = 1;
/** The pane route ids below the app route. */
const routeIds = (entry: Entry | undefined) =>
  entry?.location.route.matches
    .map((match) => match.id)
    .filter((id) => id !== 'app');
const location = appLocation;
const withPaneRoutes = (...children: SplitRouteDefinition[]): SplitRoutes => ({
  ...appRoutes,
  definitions: [
    loginRoute,
    { ...appRoute, children: [...appRoute.children, ...children] },
  ],
});
const never = () => new Promise<boolean>(() => {});

let cleanup: (() => void) | undefined;
const track = <T extends { dispose: () => void }>(context: T) => {
  cleanup = context.dispose;
  return context;
};

afterEach(() => {
  cleanup?.();
  cleanup = undefined;
  vi.useRealTimers();
  vi.restoreAllMocks();
});

describe('split router', () => {
  it('starts ready with one pane per URL segment and records pane state in place', () => {
    const { router, history } = track(setup('/mail/t1/~/drive'));
    expect(router.ready()).toBe(true);
    expect(router.panes()).toEqual(['pane-1', 'pane-2']);
    expect(history.entries()).toHaveLength(1);
    expect(history.read().state?.panes.map((pane) => pane.pane)).toEqual([
      'pane-1',
      'pane-2',
    ]);
  });

  it('navigates one pane without touching the others', () => {
    const { router, history, pane } = track(setup('/home/~/drive'));
    const drive = router.entry(pane(1));

    const result = router.navigatePane(pane(0), '/mail/t1');
    expect(result).toEqual({ status: 'committed', pane: pane(0) });
    expect(router.entry(pane(1))).toBe(drive);
    expect(router.arrival(pane(1))).toBe('fresh');
    expect(history.entries().map((entry) => entry.path)).toEqual([
      '/home/~/drive',
      '/mail/t1/~/drive',
    ]);
  });

  it('replaces a URL whose panes sit under different top-level routes with the default route', () => {
    const { router, history } = track(setup('/login/~/home'));
    expect(router.panes().map((id) => routeIds(router.entry(id)))).toEqual([
      ['home'],
    ]);
    expect(history.entries().map((entry) => entry.path)).toEqual(['/home']);
  });

  it('turns a pane navigation outside the shared top-level route into a whole-window one, and Back rebuilds the panes', async () => {
    const { router, history, pane } = track(setup('/home/~/mail'));
    await router.navigatePane(pane(1), '/login');
    expect(
      router.panes().map((id) => router.entry(id)?.location.route.matches)
    ).toEqual([[{ id: 'login', params: {} }]]);
    expect(history.entries().map((entry) => entry.path)).toEqual([
      '/home/~/mail',
      '/login',
    ]);

    history.back();
    expect(router.panes().map((id) => routeIds(router.entry(id)))).toEqual([
      ['home'],
      ['mail'],
    ]);
  });

  it('skips entries under another top-level route on pane Back while other panes share the app route', async () => {
    const { router, pane } = track(setup('/home'));
    await router.navigatePane(pane(0), '/login');
    await router.navigatePane(pane(0), '/mail');
    await router.open('/drive', { newPane: true, source: pane(0) });
    expect(router.panes()).toHaveLength(2);

    expect(router.canGo(pane(0), -1)).toBe(true);
    await router.navigatePane(pane(0), -1);
    expect(routeIds(router.entry(pane(0)))).toEqual(['home']);
    expect(router.canGo(pane(0), -1)).toBe(false);
  });

  it('pane back replaces the browser entry and records how the pane arrived', async () => {
    const { router, history, pane } = track(setup('/home'));
    await router.navigatePane(pane(0), '/mail');
    await router.navigatePane(pane(0), -1);
    expect(routeIds(router.entry(pane(0)))).toEqual(['home']);
    expect(router.arrival(pane(0))).toBe('back');
    expect(router.canGo(pane(0), 1)).toBe(true);
    expect(history.entries().map((entry) => entry.path)).toEqual([
      '/home',
      '/home',
    ]);
  });

  it('browser back brings a pane back through its own history', async () => {
    const { router, history, paneStore, pane } = track(setup('/home/~/drive'));
    await router.navigatePane(pane(0), '/mail');
    const drive = router.entry(pane(1));
    history.back();
    expect(routeIds(router.entry(pane(0)))).toEqual(['home']);
    expect(router.arrival(pane(0))).toBe('back');
    expect(paneStore.read(pane(0))).toMatchObject({ index: 0 });
    expect(paneStore.read(pane(0))?.entries).toHaveLength(2);
    expect(router.entry(pane(1))).toBe(drive);
  });

  it('a leave guard can refuse browser back, and the URL is put back', async () => {
    const { router, history, pane } = track(setup('/home'));
    await router.navigatePane(pane(0), '/mail');
    router.registerGuard(pane(0), PANE_ROUTE_LEVEL, () => false);
    history.back();
    expect(routeIds(router.entry(pane(0)))).toEqual(['mail']);
    expect(history.index()).toBe(1);
    expect(history.read().path).toBe('/mail');
  });

  it('ignores the report of its own revert landing', async () => {
    vi.useFakeTimers();
    const { router, solid } = track(setupSolid('/app/home'));
    vi.runAllTimers();
    const pane = router.panes()[0]!;
    await router.navigatePane(pane, '/mail');
    vi.runAllTimers();
    const mail = router.entry(pane);
    router.registerGuard(pane, PANE_ROUTE_LEVEL, () => false);

    solid.traverse(-1);
    await new Promise<void>((resolve) => queueMicrotask(resolve));
    vi.runAllTimers();
    expect(router.entry(pane)).toBe(mail);
    expect(solid.calls.map(([to]) => to)).toEqual(['/home', '/mail', 1]);
    expect(solid.location.pathname).toBe('/app/mail');
  });

  it('guards same-view search history through the Solid Router adapter', async () => {
    vi.useFakeTimers();
    const { router, solid } = track(setupSolid('/app/drive'));
    vi.runAllTimers();
    const pane = router.panes()[0]!;
    await router.updateSearch(pane, 'drive', { sort: ['date'] });
    vi.runAllTimers();
    const current = router.entry(pane);
    const guard = vi.fn(() => false);
    router.registerGuard(pane, PANE_ROUTE_LEVEL, guard, { search: ['drive'] });
    solid.traverse(-1);
    await new Promise<void>((resolve) => queueMicrotask(resolve));
    vi.runAllTimers();
    expect(guard).toHaveBeenCalledOnce();
    expect(router.entry(pane)).toBe(current);
    expect(solid.location.search).toBe('?s0.drive.sort=date');
  });

  it('keeps an async-guarded navigation pending until the guard settles', async () => {
    const { router, pane } = track(setup('/home'));
    let allow: (value: boolean) => void = () => {};
    router.registerGuard(
      pane(0),
      PANE_ROUTE_LEVEL,
      () =>
        new Promise<boolean>((resolve) => {
          allow = resolve;
        })
    );
    const result = router.navigatePane(pane(0), '/mail');
    expect(isPromise(result)).toBe(true);
    expect(routeIds(router.pending(pane(0))?.to)).toEqual(['mail']);
    expect(routeIds(router.entry(pane(0)))).toEqual(['home']);
    allow(true);
    await expect(result).resolves.toMatchObject({ status: 'committed' });
    expect(router.pending(pane(0))).toBeUndefined();
    expect(routeIds(router.entry(pane(0)))).toEqual(['mail']);
  });

  it('a newer navigation in the same pane supersedes a pending one', async () => {
    const { router, pane } = track(
      setup('/home', {
        middleware: [
          async ({ path }) => {
            if (path === '/mail')
              await new Promise((done) => setTimeout(done, 10));
          },
        ],
      })
    );
    expect(router.ready()).toBe(false);
    await router.settled();
    expect(router.ready()).toBe(true);
    const first = router.navigatePane(pane(0), '/mail');
    const second = router.navigatePane(pane(0), '/drive');
    await expect(first).resolves.toEqual({ status: 'cancelled' });
    await expect(second).resolves.toMatchObject({ status: 'committed' });
    expect(routeIds(router.entry(pane(0)))).toEqual(['drive']);
  });

  it('a superseded navigation settles even when its guard never does', async () => {
    const { router, pane } = track(setup('/home'));
    const unregister = router.registerGuard(pane(0), PANE_ROUTE_LEVEL, never);
    const first = router.navigatePane(pane(0), '/mail');
    unregister();
    const second = router.navigatePane(pane(0), '/drive');
    await expect(first).resolves.toEqual({ status: 'cancelled' });
    expect(second).toMatchObject({ status: 'committed' });
  });

  it('ignores a superseded navigation whose guard answers late', async () => {
    const { router, pane } = track(setup('/home'));
    const answers: ((allowed: boolean) => void)[] = [];
    router.registerGuard(
      pane(0),
      PANE_ROUTE_LEVEL,
      () => new Promise<boolean>((resolve) => answers.push(resolve))
    );
    const first = router.navigatePane(pane(0), '/mail');
    const second = router.navigatePane(pane(0), '/drive');
    answers[0]!(true);
    answers[1]!(false);
    await expect(first).resolves.toEqual({ status: 'cancelled' });
    await expect(second).resolves.toEqual({ status: 'cancelled' });
    expect(routeIds(router.entry(pane(0)))).toEqual(['home']);
  });

  it('browser back cancels a pane navigation still in flight', async () => {
    const { router, history, pane } = track(setup('/home'));
    await router.navigatePane(pane(0), '/mail');
    let allow: (allowed: boolean) => void = () => {};
    router.registerGuard(pane(0), PANE_ROUTE_LEVEL, ({ cause }) =>
      cause === 'external'
        ? true
        : new Promise<boolean>((resolve) => {
            allow = resolve;
          })
    );
    const drive = router.navigatePane(pane(0), '/drive');
    history.back();
    allow(true);
    await expect(drive).resolves.toEqual({ status: 'cancelled' });
    expect(routeIds(router.entry(pane(0)))).toEqual(['home']);
  });

  it('mounts the URL even when middleware cancels the initial load', () => {
    const { router, pane } = track(
      setup('/mail', { middleware: [({ cancel }) => cancel()] })
    );
    expect(router.ready()).toBe(true);
    expect(routeIds(router.entry(pane(0)))).toEqual(['mail']);
  });

  it('settles commands waiting on the initial load when disposed', async () => {
    const { router, dispose } = setup('/home', {
      middleware: [() => new Promise<void>(() => {})],
    });
    const opened = router.open('/mail', { newPane: true });
    dispose();
    await expect(opened).resolves.toEqual({ status: 'cancelled' });
  });

  it('waits for an async initial load before opening a pane', async () => {
    const { router } = track(
      setup('/home/~/drive', { middleware: [async () => {}] })
    );
    expect(router.ready()).toBe(false);
    const opened = router.open('/mail', { newPane: true });
    await expect(opened).resolves.toEqual({
      status: 'committed',
      pane: 'pane-3',
    });
    expect(router.ready()).toBe(true);
    expect(router.panes()).toEqual(['pane-1', 'pane-2', 'pane-3']);
  });

  it('drops commands still waiting on a revert once disposed', async () => {
    vi.useFakeTimers();
    const { router, solid } = track(setupSolid('/app/home'));
    vi.runAllTimers();
    const pane = router.panes()[0]!;
    await router.navigatePane(pane, '/mail');
    vi.runAllTimers();
    router.registerGuard(pane, PANE_ROUTE_LEVEL, never);
    solid.traverse(-1);

    const rewrite = router.rewriteCurrent(pane, '/drive');
    router.move(pane, 0);
    router.dispose();
    await expect(rewrite).resolves.toEqual({ status: 'cancelled' });
    vi.runAllTimers();
    expect(solid.calls.map(([to]) => to)).toEqual(['/home', '/mail', 1]);
  });

  it('a pane command cancels a pending browser back and reverts it first', async () => {
    const { router, history, pane } = track(setup('/home/~/drive'));
    await router.navigatePane(pane(0), '/mail');
    let guardSignal: AbortSignal | undefined;
    router.registerGuard(pane(0), PANE_ROUTE_LEVEL, ({ signal }) => {
      guardSignal = signal;
      return never();
    });
    history.back();
    expect(routeIds(router.pending(pane(0))?.to)).toEqual(['home']);

    expect(router.navigatePane(pane(1), '/drive/folder/f1')).toMatchObject({
      status: 'committed',
    });
    expect(guardSignal?.aborted).toBe(true);
    expect(router.pending(pane(0))).toBeUndefined();
    expect(routeIds(router.entry(pane(0)))).toEqual(['mail']);
    expect(history.entries().map((entry) => entry.path)).toEqual([
      '/home/~/drive',
      '/mail/~/drive',
      '/mail/~/drive/folder/f1',
    ]);
    expect(history.index()).toBe(2);
  });

  it('writes after the reverted back has landed', async () => {
    vi.useFakeTimers();
    const { router, solid } = track(setupSolid('/app/home'));
    vi.runAllTimers();
    const pane = router.panes()[0]!;
    await router.navigatePane(pane, '/mail');
    vi.runAllTimers();
    router.registerGuard(pane, PANE_ROUTE_LEVEL, ({ cause }) =>
      cause === 'external' ? never() : true
    );
    solid.traverse(-1);
    expect(routeIds(router.pending(pane)?.to)).toEqual(['home']);

    const result = router.navigatePane(pane, '/drive');
    expect(isPromise(result)).toBe(true);
    await expect(result).resolves.toMatchObject({ status: 'committed' });
    vi.runAllTimers();
    expect(solid.calls.map(([to]) => to)).toEqual([
      '/home',
      '/mail',
      1,
      '/drive',
    ]);
    expect(solid.entries().map((entry) => entry.path)).toEqual([
      '/app/home',
      '/app/mail',
      '/app/drive',
    ]);
  });

  it('reports a pending URL navigation only for the panes it changes', async () => {
    let slow = false;
    const { router, history, pane } = track(
      setup('/home/~/drive', {
        middleware: [
          ({ path }) =>
            slow && path === '/home'
              ? new Promise<void>((done) => setTimeout(done, 5))
              : undefined,
        ],
      })
    );
    await router.navigatePane(pane(0), '/mail');
    slow = true;
    history.back();
    expect(routeIds(router.pending(pane(0))?.to)).toEqual(['home']);
    expect(router.pending(pane(1))).toBeUndefined();
    await router.settled();
    expect(routeIds(router.entry(pane(0)))).toEqual(['home']);
  });

  it('opening something another pane shows activates that pane instead', () => {
    const { router, activated, pane } = track(setup('/drive/md/d1/~/home'));
    const result = router.navigatePane(pane(1), '/md/d1');
    expect(result).toEqual({ status: 'activated', owner: pane(0) });
    expect(activated).toEqual([pane(0)]);
    expect(routeIds(router.entry(pane(1)))).toEqual(['home']);
    expect(
      router.navigatePane(pane(1), '/md/d1', { allowDuplicate: true })
    ).toMatchObject({ status: 'committed' });
  });

  it('tells the policy who shows a new pane’s destination and whether a duplicate is allowed', async () => {
    const testPolicy = createTestPolicy();
    const { router, pane } = track(setup('/md/d1/~/home', {}, testPolicy));
    const target = { newPane: true as const, source: pane(1) };

    await router.open('/md/d1', target, { allowDuplicate: true });

    expect(testPolicy.placements).toMatchObject([
      { holder: pane(0), allowDuplicate: true },
    ]);
  });

  it('opens a new pane beside the one showing the destination when the policy places it there', () => {
    const { router, activated, pane } = track(setup('/md/d1/~/home'));

    const result = router.open('/md/d1', { newPane: true, source: pane(1) });

    expect(result).toMatchObject({ status: 'committed' });
    expect(router.panes()).toHaveLength(3);
    expect(activated).toEqual([]);
  });

  it('brings up a pane that started showing a new pane’s destination after it was placed', async () => {
    let release: () => void = () => {};
    let held = false;
    const holdFirstVisit = ({ path }: { path: string }) => {
      if (path !== '/md/d1' || held) return;

      held = true;

      return new Promise<void>((resolve) => {
        release = resolve;
      });
    };
    const { router, pane } = track(
      setup('/home/~/drive', { middleware: [holdFirstVisit] })
    );

    const opened = router.open('/md/d1', { newPane: true, source: pane(1) });
    const navigated = router.navigatePane(pane(0), '/md/d1');
    release();

    await expect(opened).resolves.toEqual({
      status: 'activated',
      owner: pane(0),
    });
    await navigated;
    expect(router.panes()).toHaveLength(2);
  });

  it('skips entries another pane shows on Back and Forward, unless duplicates are allowed', async () => {
    const { router, pane } = track(setup('/home/~/home'));
    await router.navigatePane(pane(0), '/md/d1');
    await router.navigatePane(pane(0), '/drive');
    await router.navigatePane(pane(1), '/md/d1');

    await router.navigatePane(pane(0), -1);
    expect(routeIds(router.entry(pane(0)))).toEqual(['home']);
    expect(router.canGo(pane(0), 1)).toBe(true);

    await router.navigatePane(pane(0), 1, { allowDuplicate: true });
    expect(routeIds(router.entry(pane(0)))).toEqual(['block']);
  });

  it('keeps duplicates loaded from a URL', () => {
    const { router } = track(setup('/md/d1/~/md/d1'));
    expect(router.panes()).toHaveLength(2);
  });

  it('changing search in a duplicate keeps it in place', () => {
    const { router, activated, pane } = track(
      setup('/drive/md/d1/~/drive/md/d1')
    );
    expect(
      router.updateSearch(pane(1), 'drive', { sort: ['name'] })
    ).toMatchObject({ status: 'committed', pane: pane(1) });
    expect(activated).toEqual([]);
  });

  it('browser back brings back a duplicate', async () => {
    const { router, history, activated, pane } = track(setup('/home/~/md/d1'));
    await router.navigatePane(pane(0), '/md/d1', { allowDuplicate: true });
    await router.navigatePane(pane(0), '/drive');
    history.back();
    expect(routeIds(router.entry(pane(0)))).toEqual(['block']);
    expect(activated).toEqual([]);
  });

  it('opens and closes panes where the policy places them', async () => {
    const { router, history } = track(setup('/home/~/drive'));
    expect(
      router.open('/mail', {
        newPane: true,
        source: 'pane-1' as PaneId,
      })
    ).toEqual({ status: 'committed', pane: 'pane-3' });
    expect(router.panes()).toEqual(['pane-1', 'pane-3', 'pane-2']);
    expect(history.read().path).toBe('/home/~/mail/~/drive');

    expect(router.open('/home', { pane: 'pane-3' as PaneId })).toEqual({
      status: 'committed',
      pane: 'pane-3',
    });
    expect(router.close('pane-3' as PaneId)).toBe(true);
    expect(router.close('pane-2' as PaneId)).toBe(true);
    expect(router.panes()).toEqual(['pane-1']);
    expect(history.read().path).toBe('/home');

    expect(router.close('pane-1' as PaneId)).toBe(false);
    await router.navigatePane('pane-1' as PaneId, '/mail');
    expect(router.close('pane-1' as PaneId)).toBe(true);
    expect(router.panes()).toEqual(['pane-1']);
    expect(history.read().path).toBe('/home');
  });

  it('opens several panes at once without one cancelling another', async () => {
    const { router } = track(
      setup('/home', {
        middleware: [
          ({ path }) => (path === '/home' ? undefined : Promise.resolve()),
        ],
      })
    );
    const source = 'pane-1' as PaneId;
    const first = router.open('/mail', { newPane: true, source });
    const second = router.open('/drive', { newPane: true, source });
    await expect(first).resolves.toEqual({
      status: 'committed',
      pane: 'pane-2',
    });
    await expect(second).resolves.toEqual({
      status: 'committed',
      pane: 'pane-3',
    });
    expect(router.panes()).toEqual(['pane-1', 'pane-2', 'pane-3']);
  });

  it('lets the policy open in an existing pane when enough are open', () => {
    const testPolicy = createTestPolicy({ maxPanes: 2 });
    const { router } = track(setup('/home/~/drive', {}, testPolicy));
    const intent = { replaceWhenFull: true };
    expect(
      router.open('/mail', {
        newPane: true,
        source: 'pane-2' as PaneId,
        intent,
      })
    ).toEqual({ status: 'committed', pane: 'pane-2' });
    expect(router.panes()).toEqual(['pane-1', 'pane-2']);
    expect(routeIds(router.entry('pane-2' as PaneId))).toEqual(['mail']);
    expect(testPolicy.placements).toEqual([
      {
        destination: location('mail'),
        source: 'pane-2',
        intent,
        allowDuplicate: false,
        opening: 0,
        panes: ['pane-1', 'pane-2'],
      },
    ]);
  });

  it('keeps a pane the policy pins, without asking its guards', () => {
    const { router } = track(
      setup(
        '/home/~/mail',
        {},
        createTestPolicy({ pinned: ['pane-1' as PaneId] })
      )
    );
    const guard = vi.fn(() => true);
    router.registerGuard('pane-1' as PaneId, PANE_ROUTE_LEVEL, guard);
    expect(router.close('pane-1' as PaneId)).toBe(false);
    expect(router.panes()).toEqual(['pane-1', 'pane-2']);
    expect(guard).not.toHaveBeenCalled();
  });

  it('navigates from the base, keeping the pane that already shows the destination', () => {
    const { router, history } = track(setup('/home/~/mail/~/drive'));
    const [home, mail, drive] = router.panes();
    const mailEntry = router.entry(mail!);
    let allowDrive = false;
    router.registerGuard(drive!, PANE_LEVEL, () => allowDrive);

    expect(router.navigate('/mail')).toMatchObject({ status: 'cancelled' });
    expect(router.panes()).toEqual([home, mail, drive]);

    allowDrive = true;
    expect(router.navigate('/mail')).toMatchObject({ status: 'committed' });
    expect(router.panes()).toEqual([mail]);
    expect(router.entry(mail!)).toBe(mailEntry);
    expect(history.entries().map((entry) => entry.path)).toEqual([
      '/home/~/mail/~/drive',
      '/mail',
    ]);
  });

  it('keeps panes that already show their entry when a base navigation reorders them', async () => {
    const { router, history } = track(setup('/home/~/mail'));
    const [home] = router.panes();

    await router.navigate('/drive/~/home');
    expect(router.panes().map((id) => routeIds(router.entry(id)))).toEqual([
      ['drive'],
      ['home'],
    ]);
    expect(router.panes()[1]).toBe(home);
    expect(history.read().path).toBe('/drive/~/home');

    await router.navigate({ location: location('mail') });
    expect(router.panes().map((id) => routeIds(router.entry(id)))).toEqual([
      ['mail'],
    ]);
  });

  it('closing the last pane can go back to an earlier entry', async () => {
    const closeLast: SplitCloseAction = {
      type: 'back-to',
      to: (entry) => routeIds(entry)?.[0] === 'mail',
      otherwise: { type: 'navigate', destination: homeLocation, replace: true },
    };
    const { router, pane } = track(
      setup('/mail', {}, createTestPolicy({ closeLast }))
    );
    await router.navigatePane(pane(0), '/drive');
    expect(router.close(pane(0))).toBe(true);
    expect(routeIds(router.entry(pane(0)))).toEqual(['mail']);
    expect(router.canGo(pane(0), 1)).toBe(true);
  });

  it('closing the last pane can replace it without a back entry', () => {
    const closeLast: SplitCloseAction = {
      type: 'back-to',
      to: (entry) => routeIds(entry)?.[0] === 'mail',
      otherwise: { type: 'navigate', destination: homeLocation, replace: true },
    };
    const { router, history, pane } = track(
      setup('/drive', {}, createTestPolicy({ closeLast }))
    );
    expect(router.close(pane(0))).toBe(true);
    expect(routeIds(router.entry(pane(0)))).toEqual(['home']);
    expect(router.canGo(pane(0), -1)).toBe(false);
    expect(history.entries()).toHaveLength(1);
  });

  it('keeps the hash of the URL it follows through a redirect', () => {
    const { history } = track(
      setup('/home#focus', {
        middleware: [
          ({ path, redirect }) =>
            path === '/home' ? redirect('/mail') : undefined,
        ],
      })
    );
    expect(history.read()).toMatchObject({ path: '/mail', hash: '#focus' });
  });

  it('writes an outside navigation with its own hash and global search', async () => {
    const { history } = track(setup('/home?referral_code=old#top'));
    await history.navigate('/mail/t2?referral_code=new#frag');
    expect(history.read()).toMatchObject({
      path: '/mail/t2',
      search: '?referral_code=new',
      hash: '#frag',
    });
  });

  it('a leave guard can keep a pane open', () => {
    const { router } = track(setup('/home/~/mail'));
    router.registerGuard('pane-2' as PaneId, PANE_ROUTE_LEVEL, () => false);
    expect(router.close('pane-2' as PaneId)).toBe(false);
    expect(router.panes()).toHaveLength(2);
  });

  it('shows the catch-all route in an unmatched pane and loads the others', () => {
    const { router, pane } = track(setup('/mail/t1/~/no/such'));
    expect(routeIds(router.entry(pane(0)))).toEqual(['mail', 'mail-thread']);
    expect(routeIds(router.entry(pane(1)))).toEqual(['not-found']);
  });

  it('takes over outside navigations into the panes', async () => {
    const { router, history, pane } = track(setup('/home'));
    await expect(history.navigate('/mail/t2')).resolves.toBe(false);
    expect(routeIds(router.entry(pane(0)))).toEqual(['mail', 'mail-thread']);
    expect(history.entries().map((entry) => entry.path)).toEqual([
      '/home',
      '/mail/t2',
    ]);
  });

  it('commits in the same tick without data preloads and waits for them within a budget', async () => {
    const preload = vi.fn(() => new Promise(() => {}));
    const routes = withPaneRoutes(
      defineRoute({ id: 'slow', path: 'slow', preload })
    );
    const { router, pane } = track(
      setup('/home', { routes, preloadBudgetMs: 5 })
    );
    expect(isPromise(router.navigatePane(pane(0), '/mail'))).toBe(false);

    const result = router.navigatePane(pane(0), '/slow');
    expect(isPromise(result)).toBe(true);
    expect(preload).toHaveBeenCalledWith(
      expect.objectContaining({ intent: 'navigate', params: {} })
    );
    await expect(result).resolves.toMatchObject({ status: 'committed' });
    expect(routeIds(router.entry(pane(0)))).toEqual(['slow']);
  });

  it('logs a preload that throws and still navigates', () => {
    const error = vi.spyOn(console, 'error').mockImplementation(() => {});
    const routes = withPaneRoutes(
      defineRoute({
        id: 'broken',
        path: 'broken',
        preload: () => {
          throw new Error('boom');
        },
      })
    );
    const { router, pane } = track(setup('/home', { routes }));
    expect(router.navigatePane(pane(0), '/broken')).toEqual({
      status: 'committed',
      pane: pane(0),
    });
    expect(error).toHaveBeenCalledWith(
      'Split route "broken" preload failed',
      expect.any(Error)
    );
  });

  it('writes search as a new entry or in place', async () => {
    const { router, history, pane } = track(setup('/drive'));
    const first = router.entry(pane(0))!.id;
    await router.updateSearch(
      pane(0),
      'drive',
      { sort: ['name'] },
      { history: 'replace' }
    );
    expect(router.entry(pane(0))!.id).toBe(first);
    expect(history.read().search).toBe('?s0.drive.sort=name');
    expect(history.entries()).toHaveLength(1);

    await router.updateSearch(pane(0), 'drive', { sort: ['date'] });
    expect(router.entry(pane(0))!.id).not.toBe(first);
    expect(history.entries()).toHaveLength(2);
  });

  it('only opts watched search namespaces into guards while views remain mounted', () => {
    const routes = withPaneRoutes(
      defineRoute({
        id: 'scheduling',
        path: 'scheduling',
        search: ['scheduling', 'other'],
      })
    );
    const { router, pane } = track(setup('/scheduling', { routes }));
    const ordinary = vi.fn(() => false);
    const watched = vi.fn(() => false);
    router.registerGuard(pane(0), PANE_ROUTE_LEVEL, ordinary);
    router.registerGuard(pane(0), PANE_ROUTE_LEVEL, watched, {
      search: ['scheduling'],
    });
    expect(
      router.updateSearch(pane(0), 'other', { value: ['updated'] })
    ).toMatchObject({ status: 'committed' });
    expect(ordinary).not.toHaveBeenCalled();
    expect(watched).not.toHaveBeenCalled();
    expect(
      router.updateSearch(pane(0), 'scheduling', { tab: ['page'] })
    ).toMatchObject({ status: 'cancelled' });
    expect(watched).toHaveBeenCalledOnce();
    expect(ordinary).not.toHaveBeenCalled();
    expect(router.entry(pane(0))?.location.search?.scheduling).toBeUndefined();
  });

  it('awaits watched search guards on browser history and restores refused URLs', async () => {
    const routes = withPaneRoutes(
      defineRoute({
        id: 'scheduling',
        path: 'scheduling',
        search: ['scheduling'],
      })
    );
    const { router, history, pane } = track(setup('/scheduling', { routes }));
    await router.updateSearch(pane(0), 'scheduling', {
      tab: ['page'],
      owner: ['me'],
    });
    let answer!: (allowed: boolean) => void;
    const guard = vi.fn(
      () =>
        new Promise<boolean>((resolve) => {
          answer = resolve;
        })
    );
    router.registerGuard(pane(0), PANE_ROUTE_LEVEL, guard, {
      search: ['scheduling'],
    });
    const current = router.entry(pane(0));
    const url = history.read();
    history.back();
    expect(guard).toHaveBeenCalledOnce();
    expect(router.entry(pane(0))).toBe(current);
    answer(false);
    await router.settled();
    expect(router.entry(pane(0))).toBe(current);
    expect(history.read()).toEqual(url);
    expect(history.index()).toBe(1);
    history.back();
    answer(true);
    await router.settled();
    expect(router.entry(pane(0))?.location.search?.scheduling).toBeUndefined();
    expect(history.index()).toBe(0);
  });

  it('jumps back to the nearest matching entry', async () => {
    const { router, pane } = track(setup('/home'));
    await router.navigatePane(pane(0), '/mail');
    await router.navigatePane(pane(0), '/drive');
    expect(
      router.goBackTo(pane(0), (entry) => routeIds(entry)?.[0] === 'home')
    ).toBe(true);
    expect(routeIds(router.entry(pane(0)))).toEqual(['home']);
    expect(router.goBackTo(pane(0), () => true)).toBe(false);
  });

  it('removing entries cancels a pending traversal in that pane', async () => {
    const { router, pane } = track(setup('/home'));
    await router.navigatePane(pane(0), '/mail');
    await router.navigatePane(pane(0), '/drive');
    router.registerGuard(pane(0), PANE_ROUTE_LEVEL, never);
    const back = router.navigatePane(pane(0), -1);
    expect(routeIds(router.pending(pane(0))?.to)).toEqual(['mail']);

    const isMail = (entry: Entry) => routeIds(entry)?.[0] === 'mail';
    expect(router.removeEntries(pane(0), isMail)).toBe(true);
    await expect(back).resolves.toEqual({ status: 'cancelled' });
    expect(router.pending(pane(0))).toBeUndefined();
    expect(routeIds(router.entry(pane(0)))).toEqual(['drive']);
    expect(router.canGo(pane(0), -1)).toBe(true);
    expect(router.removeEntries(pane(0), isMail)).toBe(false);
  });

  it('rewrites the current entry in place', async () => {
    const { router, history, pane } = track(setup('/md/draft'));
    const id = router.entry(pane(0))!.id;
    await router.rewriteCurrent(pane(0), '/md/real');
    expect(router.entry(pane(0))!.id).toBe(id);
    expect(history.read().path).toBe('/md/real');
    expect(history.entries()).toHaveLength(1);
  });

  it('builds a single-pane href', () => {
    const { router, pane } = track(setup('/home/~/mail/t1'));
    expect(router.href(pane(1))).toBe('/mail/t1');
  });
});

describe('split router while other work is in flight', () => {
  it('keeps the entry an outside navigation came from when the new view redirects in place', async () => {
    const { router, history, pane } = track(setup('/home'));
    let redirect: ReturnType<typeof router.navigatePane> | undefined;
    const stopRedirecting = createRoot((dispose) => {
      createEffect(() => {
        const showsDrive = routeIds(router.entry(pane(0)))?.[0] === 'drive';
        if (!showsDrive) return;

        redirect = untrack(() =>
          router.navigatePane(pane(0), '/mail', { replace: true })
        );
      });

      return dispose;
    });

    await history.navigate('/drive');
    await router.settled();
    stopRedirecting();

    expect(history.entries().map((entry) => entry.path)).toEqual([
      '/home',
      '/mail',
    ]);
    expect(routeIds(router.entry(pane(0)))).toEqual(['mail']);
    await redirect;
  });

  it('lets an outside navigation replace an async initial load, then runs the open waiting on it', async () => {
    const { router, history, pane } = track(
      setup('/home', { middleware: [async () => {}] })
    );
    const opened = router.open('/mail', { newPane: true });
    const navigated = history.navigate('/drive');

    await expect(opened).resolves.toMatchObject({ status: 'committed' });
    await router.settled();
    expect(router.ready()).toBe(true);
    expect(routeIds(router.entry(pane(0)))).toEqual(['drive']);
    expect(routeIds(router.entry(pane(1)))).toEqual(['mail']);
    await navigated;
  });

  it('holds an open that follows an outside navigation during the initial load', async () => {
    const { router, history } = track(
      setup('/home', { middleware: [async () => {}] })
    );
    const navigated = history.navigate('/drive');
    const opened = router.open('/mail', { newPane: true });

    await expect(opened).resolves.toMatchObject({ status: 'committed' });
    await router.settled();
    expect(router.ready()).toBe(true);
    expect(router.panes().map((id) => routeIds(router.entry(id))?.[0])).toEqual(
      ['drive', 'mail']
    );
    await navigated;
  });

  it('asks guards registered above the first route before closing the pane', () => {
    const { router, pane } = track(setup('/home/~/mail'));
    router.registerGuard(pane(1), PANE_LEVEL, () => false);

    expect(router.close(pane(1))).toBe(false);
    expect(router.panes()).toHaveLength(2);
  });

  it('puts the URL back past every Back that a refused Back replaced', async () => {
    const { router, history, pane } = track(setup('/home'));
    await router.navigatePane(pane(0), '/mail');
    await router.navigatePane(pane(0), '/drive');
    const answers: ((allowed: boolean) => void)[] = [];
    router.registerGuard(pane(0), PANE_ROUTE_LEVEL, ({ cause }) => {
      if (cause !== 'external') return true;

      return new Promise<boolean>((resolve) => answers.push(resolve));
    });

    history.back();
    history.back();
    answers[1]!(false);
    await router.settled();

    expect(routeIds(router.entry(pane(0)))).toEqual(['drive']);
    expect(history.index()).toBe(2);
    expect(history.read().path).toBe('/drive');
  });

  it('cancels the pending departure of a pane it activates for a claim', async () => {
    const { router, activated, pane } = track(setup('/md/d1/~/home'));
    let leave: (allowed: boolean) => void = () => {};
    router.registerGuard(
      pane(0),
      PANE_ROUTE_LEVEL,
      () =>
        new Promise<boolean>((resolve) => {
          leave = resolve;
        })
    );

    const departure = router.navigatePane(pane(0), '/drive');
    expect(router.navigatePane(pane(1), '/md/d1')).toEqual({
      status: 'activated',
      owner: pane(0),
    });
    leave(true);

    await expect(departure).resolves.toEqual({ status: 'cancelled' });
    expect(routeIds(router.entry(pane(0)))).toEqual(['block']);
    expect(activated).toEqual([pane(0)]);
  });

  it('carries the search a navigation asked for to the pane already showing its resource', async () => {
    const { router, activated, pane } = track(setup('/drive/md/d1/~/home'));

    expect(
      router.navigatePane(pane(1), '/drive/md/d1', {
        search: { drive: { sort: ['name'] } },
      })
    ).toEqual({ status: 'activated', owner: pane(0) });
    await router.settled();

    expect(activated).toEqual([pane(0)]);
    expect(router.entry(pane(0))?.location.search).toEqual({
      drive: { sort: ['name'] },
    });
    expect(routeIds(router.entry(pane(1)))).toEqual(['home']);
  });

  it('keeps an owner’s pending navigation that stays on the claimed resource', async () => {
    let release: () => void = () => {};
    const { router, pane } = track(
      setup('/drive/md/d1/~/home', {
        middleware: [
          ({ cause }) => {
            if (cause !== 'search') return;

            return new Promise<void>((resolve) => {
              release = resolve;
            });
          },
        ],
      })
    );
    await router.settled();

    const sorting = router.updateSearch(pane(0), 'drive', { sort: ['date'] });
    const navigated = router.navigatePane(pane(1), '/drive/md/d1');
    release();

    await expect(sorting).resolves.toMatchObject({ status: 'committed' });
    await navigated;
    expect(router.entry(pane(0))?.location.search).toEqual({
      drive: { sort: ['date'] },
    });
  });

  it('counts opens still in flight against the policy’s limit', async () => {
    const { router } = track(
      setup(
        '/home',
        {
          middleware: [
            ({ path }) => (path === '/home' ? undefined : Promise.resolve()),
          ],
        },
        createTestPolicy({ maxPanes: 2 })
      )
    );
    const source = 'pane-1' as PaneId;

    const first = router.open('/mail', { newPane: true, source });
    const second = router.open('/drive', { newPane: true, source });
    await Promise.all([first, second]);

    expect(router.panes()).toHaveLength(2);
  });

  it('turns down a location it cannot write, leaving the pane and later writes intact', () => {
    const error = vi.spyOn(console, 'error').mockImplementation(() => {});
    const { router, history, pane } = track(setup('/drive'));
    const tooLong = 'x'.repeat(17_000);

    expect(router.updateSearch(pane(0), 'drive', { sort: [tooLong] })).toEqual({
      status: 'cancelled',
    });
    expect(
      router.rewriteCurrent(pane(0), { route: { id: 'missing' } })
    ).toEqual({
      status: 'cancelled',
    });
    expect(routeIds(router.entry(pane(0)))).toEqual(['drive']);
    expect(router.entry(pane(0))?.location.search).toBeUndefined();

    expect(router.navigatePane(pane(0), '/mail')).toMatchObject({
      status: 'committed',
    });
    expect(history.read().path).toBe('/mail');
    expect(error).toHaveBeenCalled();
    expect(error).not.toHaveBeenCalledWith(
      'Split router could not commit a navigation',
      expect.anything()
    );
  });

  it('drops a search value from the URL that is too long to write back', () => {
    const tooLong = 'x'.repeat(17_000);
    const { router, pane } = track(setup(`/drive?s0.drive.sort=${tooLong}`));

    expect(routeIds(router.entry(pane(0)))).toEqual(['drive']);
    expect(router.entry(pane(0))?.location.search).toBeUndefined();
  });

  it('reports a refused jump back as false, and a back-to close then keeps the pane', async () => {
    const closeLast: SplitCloseAction = {
      type: 'back-to',
      to: (entry) => routeIds(entry)?.[0] === 'home',
      otherwise: {
        type: 'navigate',
        destination: location('mail'),
        replace: true,
      },
    };
    const { router, pane } = track(
      setup('/home', {}, createTestPolicy({ closeLast }))
    );
    await router.navigatePane(pane(0), '/drive');
    router.registerGuard(
      pane(0),
      PANE_ROUTE_LEVEL,
      ({ to }) => routeIds(to)?.[0] !== 'home'
    );

    const isHome = (entry: Entry) => routeIds(entry)?.[0] === 'home';
    expect(await router.goBackTo(pane(0), isHome)).toBe(false);
    expect(await router.close(pane(0))).toBe(false);
    expect(routeIds(router.entry(pane(0)))).toEqual(['drive']);
  });

  it('turns down a close action that leads to no route', async () => {
    const error = vi.spyOn(console, 'error').mockImplementation(() => {});
    const closeLast: SplitCloseAction = {
      type: 'navigate',
      destination: location('missing'),
    };
    const { router, history, pane } = track(
      setup('/drive', {}, createTestPolicy({ closeLast }))
    );

    expect(await router.close(pane(0))).toBe(false);
    expect(routeIds(router.entry(pane(0)))).toEqual(['drive']);
    expect(history.read().path).toBe('/drive');
    expect(error).toHaveBeenCalledWith(
      'Split router close action leads to no route',
      closeLast.destination
    );
  });

  it('writes a replace another pane makes while one commits after that commit’s push', async () => {
    const { router, history, pane } = track(setup('/home/~/home'));
    let redirect: ReturnType<typeof router.navigatePane> | undefined;
    const stopRedirecting = createRoot((dispose) => {
      createEffect(() => {
        const showsDrive = routeIds(router.entry(pane(0)))?.[0] === 'drive';
        if (!showsDrive) return;

        redirect = untrack(() =>
          router.navigatePane(pane(1), '/mail', { replace: true })
        );
      });

      return dispose;
    });

    await router.navigatePane(pane(0), '/drive');
    await router.settled();
    stopRedirecting();

    expect(history.entries().map((entry) => entry.path)).toEqual([
      '/home/~/home',
      '/drive/~/mail',
    ]);
    await redirect;
  });

  it('keeps a Back whose view redirects in place as it mounts', async () => {
    const { router, history, pane } = track(setup('/drive'));
    await router.navigatePane(pane(0), '/mail');
    let armed = false;
    let redirect: ReturnType<typeof router.navigatePane> | undefined;
    const stopRedirecting = createRoot((dispose) => {
      createEffect(() => {
        const showsDrive = routeIds(router.entry(pane(0)))?.[0] === 'drive';
        const redirects = armed && showsDrive;
        if (!redirects) return;

        redirect = untrack(() =>
          router.navigatePane(pane(0), '/home', { replace: true })
        );
      });

      return dispose;
    });
    armed = true;

    history.back();
    await router.settled();
    stopRedirecting();

    expect(history.index()).toBe(0);
    expect(history.entries().map((entry) => entry.path)).toEqual([
      '/home',
      '/mail',
    ]);
    expect(routeIds(router.entry(pane(0)))).toEqual(['home']);
    await redirect;
  });

  it('keeps navigating after the history adapter fails a write', () => {
    const error = vi.spyOn(console, 'error').mockImplementation(() => {});
    const history = createMemoryHistory('/home');
    let failNext = false;
    const flaky: HistoryAdapter = {
      ...history,
      write(location, writeOptions) {
        if (failNext) {
          failNext = false;
          throw new Error('write failed');
        }

        history.write(location, writeOptions);
      },
    };
    const { router, pane } = track(setup('/home', { history: flaky }));

    failNext = true;
    expect(router.navigatePane(pane(0), '/mail')).toEqual({
      status: 'cancelled',
    });
    expect(router.navigatePane(pane(0), '/drive')).toMatchObject({
      status: 'committed',
    });
    expect(history.read().path).toBe('/drive');
    expect(error).toHaveBeenCalledWith(
      'Split router could not commit a navigation',
      expect.any(Error)
    );
  });

  it('settles a URL navigation that arrives while an earlier one is being put back', async () => {
    const { history, adapter, landAll } = slowRevertHistory('/home');
    const { router, pane } = track(setup('/home', { history: adapter }));
    await router.navigatePane(pane(0), '/mail');
    await router.navigatePane(pane(0), '/drive');
    router.registerGuard(pane(0), PANE_ROUTE_LEVEL, ({ cause }) =>
      cause === 'external' ? never() : true
    );

    history.back();
    const navigated = router.navigatePane(pane(0), '/drive/folder/f1');
    history.back();
    await landAll();

    await expect(navigated).resolves.toMatchObject({ status: 'committed' });
    await expect(router.settled()).resolves.toBeUndefined();
    expect(history.read().path).toBe('/drive/folder/f1');
    expect(routeIds(router.entry(pane(0)))).toEqual(['drive', 'drive-folder']);
  });

  it('puts back a Back that arrives while others are put back before them', async () => {
    const { history, adapter, landAll } = slowRevertHistory('/home');
    const { router, pane } = track(setup('/home', { history: adapter }));
    await router.navigatePane(pane(0), '/mail');
    await router.navigatePane(pane(0), '/drive');
    await router.navigatePane(pane(0), '/md/d1');
    let refuse: () => void = () => {};
    router.registerGuard(pane(0), PANE_ROUTE_LEVEL, ({ cause }) => {
      if (cause !== 'external') return true;

      return new Promise<boolean>((resolve) => {
        refuse = () => resolve(false);
      });
    });

    history.back();
    history.back();
    refuse();
    await new Promise((resolve) => setTimeout(resolve, 0));
    history.back();
    await landAll();
    await router.settled();

    expect(history.index()).toBe(3);
    expect(history.read().path).toBe('/md/d1');
    expect(routeIds(router.entry(pane(0)))).toEqual(['block']);
  });

  it('opens a pane that already shows the destination by activating it', () => {
    const { router, activated, pane } = track(setup('/mail/t1/~/home'));

    expect(router.open('/mail/t1', { pane: pane(0) })).toEqual({
      status: 'activated',
      owner: pane(0),
    });
    expect(activated).toEqual([pane(0)]);
  });

  it('checks again before running a waiting action that a new Back overtook', async () => {
    const { router, history, pane, paneStore } = track(setup('/home'));
    await router.navigatePane(pane(0), '/mail');
    let allow: (allowed: boolean) => void = () => {};
    router.registerGuard(pane(0), PANE_ROUTE_LEVEL, ({ cause }) => {
      if (cause !== 'external') return true;

      return new Promise<boolean>((resolve) => {
        allow = resolve;
      });
    });
    let redirected = false;
    let redirect: ReturnType<typeof router.navigatePane> | undefined;
    const stopRedirecting = createRoot((dispose) => {
      createEffect(() => {
        const showsDrive = routeIds(router.entry(pane(0)))?.[0] === 'drive';
        const redirects = showsDrive && !redirected;
        if (!redirects) return;

        redirected = true;
        redirect = untrack(() =>
          router.navigatePane(pane(0), '/drive/folder/f1', { replace: true })
        );
      });

      return dispose;
    });

    const navigated = router.navigatePane(pane(0), '/drive');
    history.back();
    await Promise.resolve();
    await Promise.resolve();
    allow(true);
    await router.settled();
    await navigated;
    stopRedirecting();

    expect(routeIds(router.entry(pane(0)))).toEqual(['drive', 'drive-folder']);
    expect(history.index()).toBe(2);
    expect(history.read().path).toBe('/drive/folder/f1');
    expect(paneStore.read(pane(0))?.index).toBe(2);
    await redirect;
  });

  it('writes the URL again after the history adapter failed to write it', async () => {
    vi.spyOn(console, 'error').mockImplementation(() => {});
    const history = createMemoryHistory('/home');
    let failNext = false;
    const flaky: HistoryAdapter = {
      ...history,
      write(location, writeOptions) {
        if (failNext) {
          failNext = false;
          throw new Error('write failed');
        }

        history.write(location, writeOptions);
      },
    };
    const { router, pane } = track(setup('/home', { history: flaky }));

    failNext = true;
    await router.navigatePane(pane(0), '/mail');
    await router.rewriteCurrent(pane(0), '/mail');

    expect(history.read().path).toBe('/mail');
  });

  it('ignores a host location outside the router’s base', () => {
    vi.useFakeTimers();
    const { router, solid } = track(setupSolid('/app/mail'));
    vi.runAllTimers();

    solid.show('/elsewhere', undefined);
    vi.runAllTimers();

    expect(routeIds(router.entry(router.panes()[0]!))).toEqual(['mail']);
  });

  it('drops a URL write still queued when the router is disposed', async () => {
    vi.useFakeTimers();
    const { router, solid, dispose } = setupSolid('/app/home');
    vi.runAllTimers();

    await router.navigatePane(router.panes()[0]!, '/mail');
    dispose();
    vi.runAllTimers();

    expect(solid.calls.map(([to]) => to)).toEqual(['/home']);
  });

  it('asks leave guards when Back or Forward leaves the router’s routes', () => {
    vi.useFakeTimers();
    const { router, solid } = track(setupSolid('/app/home', ['/settings']));
    vi.runAllTimers();
    const guard = vi.fn(() => false);
    router.registerGuard(router.panes()[0]!, PANE_ROUTE_LEVEL, guard);

    expect(solid.pop(1).defaultPrevented).toBe(true);
    expect(guard).toHaveBeenCalledTimes(1);
    expect(solid.landed()).toBe('/app/home');

    guard.mockReturnValue(true);
    expect(solid.pop(1).defaultPrevented).toBe(false);
    expect(solid.landed()).toBe('/settings');
  });

  it('drops a queued write when a navigation leaves the router’s routes', async () => {
    vi.useFakeTimers();
    const { router, solid } = track(setupSolid('/app/home'));
    vi.runAllTimers();

    await router.navigatePane(router.panes()[0]!, '/mail');
    expect(solid.leave('/settings').defaultPrevented).toBe(false);
    vi.runAllTimers();

    expect(solid.calls.map(([to]) => to)).toEqual(['/home']);
  });

  it('moves the cursor on Back to an entry that looks like the current one', async () => {
    const { router, history, paneStore, pane } = track(setup('/home'));
    await router.navigatePane(pane(0), '/home', { props: { note: 1 } });
    expect(paneStore.read(pane(0))?.entries).toHaveLength(2);

    history.back();
    expect(paneStore.read(pane(0))?.index).toBe(0);
    expect(router.canGo(pane(0), -1)).toBe(false);

    history.forward();
    expect(paneStore.read(pane(0))?.index).toBe(1);
    expect(router.arrival(pane(0))).toBe('forward');
  });
});

it('cancels speculative route admission when its account router is disposed', async () => {
  let signal: AbortSignal | undefined;
  const view = setup('/home', {
    routes: {
      ...appRoutes,
      definitions: [
        {
          ...appRoute,
          preload: (context) => {
            if (context.intent === 'hover') signal = context.signal;
          },
        },
      ],
    },
  });
  const preloaded = view.router.preload(homeLocation, 'hover');
  expect(signal?.aborted).toBe(false);
  view.dispose();
  expect(signal?.aborted).toBe(true);
  await preloaded;
});

it('keeps speculative admission alive after navigation commits, until account disposal', async () => {
  const imported = Promise.withResolvers<void>();
  const requested = vi.fn();
  let admission: Promise<void> | undefined;
  let signal: AbortSignal | undefined;
  async function readAfterImport(lifetime: AbortSignal) {
    await imported.promise;
    if (!lifetime.aborted) requested();
  }
  const view = setup('/home', {
    routes: {
      ...appRoutes,
      definitions: [
        {
          ...appRoute,
          preload: (context) => {
            signal = context.signal;
            admission = readAfterImport(context.signal);
          },
        },
      ],
    },
  });
  try {
    expect(view.router.ready()).toBe(true);
    expect(signal?.aborted).toBe(false);
    imported.resolve();
    await admission;
    expect(requested).toHaveBeenCalledOnce();
  } finally {
    imported.resolve();
    await admission;
    view.dispose();
  }
  expect(signal?.aborted).toBe(true);
});