@astrale-os/cli 1.0.0-beta.28 → 1.0.0-beta.29

package/src/lib/browser-retention.ts

@@ -0,0 +1,210 @@
+/**
+ * Browser-profile retention.
+ *
+ * `astrale browser` keeps one persistent Chromium profile per host so the
+ * WorkOS cookie survives between runs. That cookie is a few kilobytes;
+ * everything Chromium accumulates around it is cache, and it accumulates
+ * without limit — a real profile here reached 373 MB, 98% of it cache.
+ *
+ * Chromium will not bound it for us. `--disk-cache-size` is measurably ignored
+ * for a profile's HTTP cache — the largest component by far — so deleting is
+ * the only lever. Two rules, cheapest first:
+ *
+ *   1. A profile untouched for longer than the age bound goes entirely. Its
+ *      WorkOS cookie has expired anyway, so it holds nothing worth the disk.
+ *   2. A surviving profile whose cache exceeds the size bound has its cache
+ *      directories removed. Cookies, Local Storage, Preferences and Local State
+ *      are never touched — the whole point of the profile is that the session
+ *      outlives the sweep.
+ *
+ * A profile whose SingletonLock names a live process is always left alone:
+ * deleting files under a running Chromium is how profiles get corrupted.
+ */
+import { readlinkSync } from 'node:fs'
+import { readdir, rm, stat } from 'node:fs/promises'
+import { join } from 'node:path'
+
+import { BROWSER_DIR } from './browser'
+import { readConfig } from './config'
+
+/** Reconstructible directories, relative to a profile root. Everything here can
+ *  be deleted with no user-visible consequence beyond a colder first load. */
+const CACHE_PATHS = [
+  'Default/Cache',
+  'Default/Code Cache',
+  'Default/GPUCache',
+  'Default/DawnWebGPUCache',
+  'Default/DawnGraphiteCache',
+  'Default/Service Worker/CacheStorage',
+  'Default/Service Worker/ScriptCache',
+  'GraphiteDawnCache',
+  'GPUPersistentCache',
+  'GrShaderCache',
+  'ShaderCache',
+  'component_crx_cache',
+  'extensions_crx_cache',
+] as const
+
+export const DEFAULT_MAX_CACHE_BYTES = 50 * 1024 * 1024
+export const DEFAULT_MAX_PROFILE_AGE_DAYS = 30
+
+export type BrowserRetentionBudget = {
+  /** Cap on one profile's cache directories, not on the profile as a whole. */
+  maxCacheBytes: number
+  maxProfileAgeMs: number
+}
+
+export type BrowserSweepResult = {
+  /** Profiles deleted outright (dormant past the age bound). */
+  removed: string[]
+  /** Profiles kept, cache emptied (over the size bound). */
+  purged: string[]
+  /** Profiles a live browser was holding — left untouched. */
+  skipped: string[]
+  bytesFreed: number
+}
+
+const EMPTY: BrowserSweepResult = { removed: [], purged: [], skipped: [], bytesFreed: 0 }
+
+/** First finite, strictly positive candidate; anything else falls through to
+ *  the next one, and ultimately to the default. A typo must not mean "no cap". */
+function firstPositive(candidates: (number | string | undefined)[]): number | null {
+  for (const candidate of candidates) {
+    if (candidate === undefined) continue
+    const n = typeof candidate === 'string' ? Number(candidate.trim()) : candidate
+    if (Number.isFinite(n) && n > 0) return n
+  }
+  return null
+}
+
+/** Resolved budget: env over config over defaults. */
+export async function browserRetentionBudget(): Promise<BrowserRetentionBudget> {
+  const browser = (await readConfig().catch(() => null))?.browser
+  const bytes =
+    firstPositive([process.env.ASTRALE_BROWSER_MAX_CACHE_BYTES, browser?.maxCacheBytes]) ??
+    DEFAULT_MAX_CACHE_BYTES
+  const days =
+    firstPositive([process.env.ASTRALE_BROWSER_MAX_PROFILE_AGE_DAYS, browser?.maxProfileAgeDays]) ??
+    DEFAULT_MAX_PROFILE_AGE_DAYS
+  return { maxCacheBytes: bytes, maxProfileAgeMs: days * 24 * 60 * 60 * 1000 }
+}
+
+/** True when a process with this pid exists. EPERM means it exists but is not
+ *  ours — still alive, and still a reason not to touch the profile. */
+function isLive(pid: number): boolean {
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch (e) {
+    return (e as NodeJS.ErrnoException).code === 'EPERM'
+  }
+}
+
+/**
+ * Whether a live browser holds this profile. SingletonLock is a symlink whose
+ * target is `<hostname>-<pid>` and which does NOT resolve to a real file, so it
+ * must be read with readlink, never stat'ed. A stale lock (dead pid) is not a
+ * reason to skip — Chromium leaves those behind after a crash.
+ */
+export function heldByLiveBrowser(profileDir: string): boolean {
+  let target: string
+  try {
+    target = readlinkSync(join(profileDir, 'SingletonLock'))
+  } catch {
+    return false
+  }
+  const pid = Number(target.slice(target.lastIndexOf('-') + 1))
+  return Number.isInteger(pid) && pid > 0 && isLive(pid)
+}
+
+/** Bytes under `dir`, or 0 when it is missing or unreadable. */
+async function directoryBytes(dir: string): Promise<number> {
+  let entries
+  try {
+    entries = await readdir(dir, { withFileTypes: true })
+  } catch {
+    return 0
+  }
+  let total = 0
+  for (const entry of entries) {
+    const path = join(dir, entry.name)
+    if (entry.isDirectory()) {
+      total += await directoryBytes(path)
+    } else if (entry.isFile()) {
+      try {
+        total += (await stat(path)).size
+      } catch {
+        /* raced away mid-walk */
+      }
+    }
+  }
+  return total
+}
+
+/** Cumulative size of one profile's cache directories. */
+export async function profileCacheBytes(profileDir: string): Promise<number> {
+  let total = 0
+  for (const relative of CACHE_PATHS) total += await directoryBytes(join(profileDir, relative))
+  return total
+}
+
+/** Delete every cache directory of a profile; returns bytes actually freed. */
+async function purgeCache(profileDir: string): Promise<number> {
+  const before = await profileCacheBytes(profileDir)
+  for (const relative of CACHE_PATHS) {
+    await rm(join(profileDir, relative), { recursive: true, force: true }).catch(() => {
+      /* best effort — retention must never break the browser command */
+    })
+  }
+  return before - (await profileCacheBytes(profileDir))
+}
+
+/**
+ * Apply both rules across every profile under `dir`. Never throws: a failed
+ * sweep must not stop the user from driving a browser.
+ */
+export async function sweepBrowserProfiles(
+  options: { dir?: string; budget?: BrowserRetentionBudget; now?: number } = {},
+): Promise<BrowserSweepResult> {
+  const dir = options.dir ?? BROWSER_DIR
+  let names: string[]
+  try {
+    names = (await readdir(dir, { withFileTypes: true }))
+      .filter((e) => e.isDirectory())
+      .map((e) => e.name)
+  } catch {
+    return EMPTY
+  }
+  if (names.length === 0) return EMPTY
+
+  const budget = options.budget ?? (await browserRetentionBudget())
+  const now = options.now ?? Date.now()
+  const result: BrowserSweepResult = { removed: [], purged: [], skipped: [], bytesFreed: 0 }
+
+  for (const name of names) {
+    const profileDir = join(dir, name)
+    if (heldByLiveBrowser(profileDir)) {
+      result.skipped.push(name)
+      continue
+    }
+    try {
+      // The profile root's mtime tracks USE, not writes: Chromium rewrites
+      // SingletonLock and DevToolsActivePort there on every launch, while cache
+      // writes land in subdirectories and leave the root alone.
+      const idleMs = now - (await stat(profileDir)).mtime.getTime()
+      if (idleMs > budget.maxProfileAgeMs) {
+        result.bytesFreed += await directoryBytes(profileDir)
+        await rm(profileDir, { recursive: true, force: true })
+        result.removed.push(name)
+        continue
+      }
+      if ((await profileCacheBytes(profileDir)) > budget.maxCacheBytes) {
+        result.bytesFreed += await purgeCache(profileDir)
+        result.purged.push(name)
+      }
+    } catch {
+      /* best effort, per profile — one bad profile must not stop the sweep */
+    }
+  }
+  return result
+}

package/src/lib/config.ts

@@ -6,10 +6,21 @@ import { CONFIG_PATH } from '../state/index'
 import { AdminTargetConfigSchema, DEFAULT_ADMIN_TARGET_CONFIG } from './admin-target'
 import { log } from './log'
 
+/** A retention bound, or undefined when absent or nonsensical. A bad value must
+ *  fall back to the default rather than take the whole config down with it —
+ *  and must never read as "no limit". */
+const bound = z.number().positive().finite().optional().catch(undefined)
+
 export const AstraleConfigSchema = z.object({
   issuer: z.string().url().default('https://unregistered.invalid'),
   admin: AdminTargetConfigSchema.default(DEFAULT_ADMIN_TARGET_CONFIG),
-  telemetry: z.object({ enabled: z.boolean().default(true) }).default({ enabled: true }),
+  // The retention bounds live in the schema, not just in the readers that
+  // consume them: zod strips unknown keys, so a config the CLI rewrites (see
+  // setup/steps/admin.ts) would silently drop anything declared elsewhere.
+  telemetry: z
+    .object({ enabled: z.boolean().default(true), maxAgeDays: bound, maxBytes: bound })
+    .default({ enabled: true }),
+  browser: z.object({ maxCacheBytes: bound, maxProfileAgeDays: bound }).default({}),
 })
 
 export type AstraleConfig = z.infer<typeof AstraleConfigSchema>

package/src/state/.spec/api.d.ts

@@ -1,3 +1,5 @@
+import type { SessionRouteArtifact, SessionRouteStore } from '@astrale-os/sdk/client/session'
+
 /** Environment values that affect CLI-owned state placement. */
 export interface PathEnvironment {
   readonly ASTRALE_HOME?: string
@@ -17,6 +19,7 @@ export interface Paths {
   readonly idps: string
   readonly idpSessionsDir: string
   readonly exchangeCredentials: string
+  readonly sessionRoutes: string
   idpDir(name: string): string
   idpSession(identityName: string): string
 }
@@ -35,22 +38,27 @@ export const INSTANCES_PATH: string
 export const IDPS_PATH: string
 export const IDP_SESSIONS_DIR: string
 export const EXCHANGE_CREDENTIALS_PATH: string
+export const SESSION_ROUTES_PATH: string
 
 export namespace exchange {
   interface Artifact {
-    readonly version: 1
+    readonly version: 2
     readonly entries: Record<string, Entry>
   }
 
   interface Key {
     readonly kernelIssuer: string
     readonly domainIssuer: string
-    readonly user: string
+    readonly sourceIssuer: string
+    readonly sourceSubject: string
   }
 
   interface Entry {
     readonly credential: string
     readonly expiresAt: number
+    readonly user: string
+    readonly sourceIssuer: string
+    readonly sourceSubject: string
   }
 }
 
@@ -118,6 +126,17 @@ export function updateIdentityStore<Value>(
 
 /** Atomically replace one private CLI state file through a same-directory temporary file. */
 export function atomicWrite(path: string, data: string): Promise<void>
+export function atomicWriteSync(path: string, data: string): void
+
+/** CLI filesystem representation for Kernel Client's admitted confidential route artifact. */
+export class FileSessionRouteStore implements SessionRouteStore {
+  constructor(path?: string)
+  read(): unknown
+  write(artifact: SessionRouteArtifact): void
+  clear(): void
+}
+
+export const SESSION_ROUTE_STORE: Readonly<FileSessionRouteStore>
 
 export interface FileLockOptions {
   readonly pollIntervalMs?: number

package/src/state/.spec/architecture.md

@@ -11,10 +11,24 @@ The identity registry decodes the legacy unversioned shape and current V1 envelo
 exact bytes at `identities.json.v0.bak` before publishing V1. Invalid or newer files remain untouched
 and fail closed. Identity orchestration owns key and IdP-session effects above this module.
 
-The exchange registry owns a versioned `exchange.Artifact`. Each entry is keyed by the atomic
-`(Kernel issuer, Domain issuer, registered User)` identity and stores only one inspected Domain
-credential and expiry. It reuses the same atomic-write and bounded file-lock primitives, maintains
-owner-only directory and file modes, and remains distinct from Client's process-local route cache.
+The exchange registry owns a versioned `exchange.Artifact`. Each V2 entry is keyed by the atomic
+`(Kernel issuer, Domain issuer, source issuer, source subject)` identity and stores one inspected
+Domain credential, expiry, and the exact registered Kernel User proven when that credential was
+minted, together with the exact upstream source issuer and subject that selected the entry. This lets
+a warm command validate and reuse the credential before any network `whoami` without accepting a
+refresh result filed under another source identity.
+V1 is not migrated or retained; it is discarded and replaced by the next exact exchange. The
+registry reuses the same atomic-write and bounded file-lock primitives and maintains owner-only
+directory and file modes.
+
+The session-route registry is a separate representation adapter for Kernel Client's versioned,
+bounded confidential route artifact. Kernel Client exclusively owns route keying, admission, expiry,
+and stale/miss recovery. CLI owns only synchronous owner-private JSON I/O so a new CLI process can
+reuse admitted routing state without an Admin-specific shortcut. Writes are atomic snapshots; a
+lost concurrent cache update or any read/write failure is only a future cold route miss and cannot
+change product correctness.
+Authentication logout and identity deletion remove this artifact together with exchanged Domain
+credentials so locally retired authority does not leave reusable destination bearers behind.
 
 Shape decoding, migrations, and backup policy remain with each semantic registry. Commands do not
 call these primitives directly, and Kernel Client owns no CLI filesystem state.

package/src/state/.spec/layout.ts

@@ -8,6 +8,7 @@ export default defineLayout({
     'identities.ts',
     'index.ts',
     'paths.ts',
+    'session-routes.ts',
     'tsconfig.json',
   ],
   exact: true,

package/src/state/__tests__/exchange-credentials.test.ts

@@ -1,5 +1,5 @@
 import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
-import { mkdtemp, readFile, rm, stat } from 'node:fs/promises'
+import { mkdir, mkdtemp, readFile, rm, stat, writeFile } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 
@@ -19,11 +19,22 @@ afterEach(async () => {
 
 describe('exchange credential cache', () => {
   /** @evidence TEST-CLI-EXCHANGE-CACHE-EXACT-KEY-AND-PRIVATE-MODE */
-  test('partitions by Kernel, Domain, and User under private filesystem modes', async () => {
+  test('partitions by Kernel, Domain, and source identity under private filesystem modes', async () => {
     const cache = new ExchangeCredentialCache(path)
     const now = () => 100
     const first = key('https://kernel-a.example', 'https://domain.example', 'user-a')
-    const second = key('https://kernel-a.example', 'https://domain.example', 'user-b')
+    const partitions = [
+      first,
+      key('https://kernel-b.example', first.domainIssuer, first.sourceSubject),
+      key(first.kernelIssuer, 'https://other-domain.example', first.sourceSubject),
+      key(
+        first.kernelIssuer,
+        first.domainIssuer,
+        first.sourceSubject,
+        'https://other-source.example',
+      ),
+      key(first.kernelIssuer, first.domainIssuer, 'user-b'),
+    ]
     let refreshes = 0
 
     const resolve = (candidate: typeof first) =>
@@ -31,18 +42,16 @@ describe('exchange credential cache', () => {
         candidate,
         async () => {
           refreshes += 1
-          return {
-            credential: token(candidate, 200),
-            expiresAt: 200,
-          }
+          return entry(candidate, 200)
         },
         now,
       )
 
-    await expect(resolve(first)).resolves.toBe(token(first, 200))
-    await expect(resolve(first)).resolves.toBe(token(first, 200))
-    await expect(resolve(second)).resolves.toBe(token(second, 200))
-    expect(refreshes).toBe(2)
+    for (const candidate of partitions) {
+      await expect(resolve(candidate)).resolves.toBe(token(candidate, 200))
+      await expect(resolve(candidate)).resolves.toBe(token(candidate, 200))
+    }
+    expect(refreshes).toBe(partitions.length)
     expect((await stat(path)).mode & 0o777).toBe(0o600)
     expect((await stat(join(directory, 'private'))).mode & 0o777).toBe(0o700)
   })
@@ -56,10 +65,7 @@ describe('exchange credential cache', () => {
     const refresh = async () => {
       refreshes += 1
       await new Promise((resolve) => setTimeout(resolve, 10))
-      return {
-        credential: token(candidate, 200),
-        expiresAt: 200,
-      }
+      return entry(candidate, 200)
     }
 
     const values = await Promise.all([
@@ -77,10 +83,7 @@ describe('exchange credential cache', () => {
     const candidate = key('https://kernel.example', 'https://domain.example', 'user')
     await cache.getOrRefresh(
       candidate,
-      async () => ({
-        credential: token(candidate, 120),
-        expiresAt: 120,
-      }),
+      async () => entry(candidate, 120),
       () => 50,
     )
     let refreshes = 0
@@ -88,10 +91,7 @@ describe('exchange credential cache', () => {
       candidate,
       async () => {
         refreshes += 1
-        return {
-          credential: token(candidate, 220),
-          expiresAt: 220,
-        }
+        return entry(candidate, 220)
       },
       () => 100,
     )
@@ -99,19 +99,16 @@ describe('exchange credential cache', () => {
 
     await expect(
       cache.getOrRefresh(
-        key('https://other-kernel.example', candidate.domainIssuer, candidate.user),
-        async () => ({
-          credential: token(candidate, 220),
-          expiresAt: 220,
-        }),
+        key('https://other-kernel.example', candidate.domainIssuer, candidate.sourceSubject),
+        async () => entry(candidate, 220),
         () => 100,
       ),
     ).rejects.toThrow(/inconsistent with its cache key/i)
 
     await expect(
       cache.getOrRefresh(
-        key(candidate.kernelIssuer, candidate.domainIssuer, 'other-user'),
-        async () => ({ credential: token(candidate, 220), expiresAt: 220 }),
+        key(candidate.kernelIssuer, candidate.domainIssuer, 'other-source'),
+        async () => entry(candidate, 220),
         () => 100,
       ),
     ).rejects.toThrow(/inconsistent with its cache key/i)
@@ -125,10 +122,7 @@ describe('exchange credential cache', () => {
       await expect(
         cache.getOrRefresh(
           malformedCandidate,
-          async () => ({
-            credential: token(malformedCandidate, 220, malformed),
-            expiresAt: 220,
-          }),
+          async () => entry(malformedCandidate, 220, malformed),
           () => 100,
         ),
       ).rejects.toThrow(/inconsistent with its cache key/i)
@@ -143,10 +137,7 @@ describe('exchange credential cache', () => {
     for (const candidate of [a, b]) {
       await cache.getOrRefresh(
         candidate,
-        async () => ({
-          credential: token(candidate, 200),
-          expiresAt: 200,
-        }),
+        async () => entry(candidate, 200),
         () => 100,
       )
     }
@@ -156,10 +147,60 @@ describe('exchange credential cache', () => {
     await cache.clear()
     expect(JSON.parse(await readFile(path, 'utf8')).entries).toEqual({})
   })
+
+  test('discards the V1 cache and writes only V2 after a fresh exact exchange', async () => {
+    await mkdir(join(directory, 'private'))
+    await writeFile(
+      path,
+      JSON.stringify({
+        version: 1,
+        entries: { legacy: { credential: 'legacy', expiresAt: 999 } },
+      }),
+    )
+    const cache = new ExchangeCredentialCache(path)
+    const candidate = key('https://kernel.example', 'https://domain.example', 'source-user')
+    let refreshes = 0
+    await cache.getOrRefresh(
+      candidate,
+      async () => {
+        refreshes += 1
+        return entry(candidate, 200)
+      },
+      () => 100,
+    )
+    expect(refreshes).toBe(1)
+    const stored = JSON.parse(await readFile(path, 'utf8'))
+    expect(stored.version).toBe(2)
+    expect(JSON.stringify(stored)).not.toContain('legacy')
+  })
 })
 
-function key(kernelIssuer: string, domainIssuer: string, user: string) {
-  return { kernelIssuer, domainIssuer, user }
+function key(
+  kernelIssuer: string,
+  domainIssuer: string,
+  sourceSubject: string,
+  sourceIssuer = 'https://source.example',
+) {
+  return {
+    kernelIssuer,
+    domainIssuer,
+    sourceIssuer,
+    sourceSubject,
+  }
+}
+
+function entry(
+  candidate: ReturnType<typeof key>,
+  expiresAt: number,
+  malformed?: 'outer-delegation' | 'proof-without-delegation',
+) {
+  return {
+    credential: token(candidate, expiresAt, malformed),
+    expiresAt,
+    user: candidate.sourceSubject,
+    sourceIssuer: candidate.sourceIssuer,
+    sourceSubject: candidate.sourceSubject,
+  }
 }
 
 function token(
@@ -170,12 +211,17 @@ function token(
   const encode = (value: unknown) => Buffer.from(JSON.stringify(value)).toString('base64url')
   const proof = `${encode({ alg: 'EdDSA', typ: 'JWT' })}.${encode({
     iss: candidate.kernelIssuer,
-    sub: candidate.user,
+    sub: candidate.sourceSubject,
     aud: candidate.kernelIssuer,
     exp,
     ...(malformed === 'proof-without-delegation'
       ? {}
-      : { delegation: { v: 1, expr: { kind: 'identity', id: candidate.user } } }),
+      : {
+          delegation: {
+            v: 1,
+            expr: { kind: 'identity', id: candidate.sourceSubject },
+          },
+        }),
   })}.signature`
   return `${encode({ alg: 'EdDSA', typ: 'JWT' })}.${encode({
     iss: candidate.domainIssuer,

package/src/state/__tests__/files.test.ts

@@ -13,7 +13,7 @@ import {
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 
-import { atomicWrite, withFileLock } from '../files'
+import { atomicWrite, atomicWriteSync, withFileLock } from '../files'
 
 let temporaryDirectory: string
 
@@ -50,6 +50,29 @@ describe('atomicWrite', () => {
   })
 })
 
+describe('atomicWriteSync', () => {
+  test('publishes a synced mode-0600 file without temporary residue', async () => {
+    const path = join(temporaryDirectory, 'sync', 'state.json')
+
+    atomicWriteSync(path, '{"value":1}')
+
+    expect(await readFile(path, 'utf-8')).toBe('{"value":1}')
+    expect((await stat(path)).mode & 0o777).toBe(0o600)
+    expect(await readdir(join(temporaryDirectory, 'sync'))).toEqual(['state.json'])
+  })
+
+  test('does not disturb the target or retain a temporary file after failure', async () => {
+    const path = join(temporaryDirectory, 'sync-target')
+    await mkdir(path)
+    await writeFile(join(path, 'retained'), 'stable')
+
+    expect(() => atomicWriteSync(path, 'replacement')).toThrow()
+
+    expect(await readFile(join(path, 'retained'), 'utf-8')).toBe('stable')
+    expect((await readdir(temporaryDirectory)).sort()).toEqual(['sync-target'])
+  })
+})
+
 describe('withFileLock', () => {
   /** @evidence TEST-CLI-STATE-LOCK-SERIALIZES */
   test('serializes contending read-modify-write transitions', async () => {

package/src/state/__tests__/fixtures/session-route-process.ts

@@ -0,0 +1,93 @@
+import type { Transport } from '@astrale-os/sdk/client'
+
+import { issuer } from '@astrale-os/sdk/auth'
+import { call, Client } from '@astrale-os/sdk/client'
+import { ClientSession } from '@astrale-os/sdk/client/session'
+import { NodeId } from '@astrale-os/sdk/graph/node'
+import { Path } from '@astrale-os/sdk/graph/path'
+import { invocation } from '@astrale-os/sdk/invocation'
+
+import { FileSessionRouteStore } from '../../session-routes'
+
+const routePath = process.argv[2]
+if (routePath === undefined) throw new Error('route artifact path is required')
+
+const sourceEndpoint = 'https://source.kernel.test/invoke'
+const sourceIssuer = issuer.accept('https://source.kernel.test')
+const destinationEndpoint = 'https://destination.application.test/invoke'
+const target = Path.id(NodeId('session-route-fresh-process'))
+let sourceAttempts = 0
+let destinationAttempts = 0
+
+const route = invocation.acceptRoute({
+  endpoint: { http: destinationEndpoint },
+  via: {
+    kind: 'via',
+    issuer: sourceIssuer,
+    publication: {
+      origin: 'destination.application.test',
+      identity: {
+        issuer: 'https://destination.application.test',
+        subject: 'destination.application.test',
+      },
+      revision: `sha256:${'1'.padStart(64, '0')}`,
+      etag: `sha256:${'1'.padStart(64, '0')}`,
+    },
+  },
+})
+const carrier = `e30.${Buffer.from(
+  JSON.stringify({ exp: Math.floor(Date.now() / 1_000) + 600 }),
+).toString('base64url')}.signature`
+const sourceDispatch: Transport['dispatch'] = async () => {
+  sourceAttempts += 1
+  return {
+    kind: 'redirect',
+    invocation: { source: sourceIssuer, id: 'source-invocation' },
+    redirect: { route, credential: carrier },
+  }
+}
+const destinationDispatch: Transport['dispatch'] = async () => {
+  destinationAttempts += 1
+  return {
+    kind: 'value',
+    value: 'done',
+    invocation: { source: sourceIssuer, id: 'destination-invocation' },
+  }
+}
+const source = new Client({ transport: { dispatch: sourceDispatch } })
+const destination = new Client({ transport: { dispatch: destinationDispatch } })
+const session = new ClientSession({
+  kernel: sourceIssuer,
+  fetch: async () =>
+    new Response(
+      JSON.stringify({
+        protocol: 'astrale-invocation',
+        version: 1,
+        issuer: sourceIssuer,
+        endpoints: { http: sourceEndpoint },
+      }),
+      { headers: { 'content-type': 'application/json' } },
+    ),
+  pool: {
+    clientFor(
+      target: Parameters<
+        NonNullable<ConstructorParameters<typeof ClientSession>[0]['pool']>['clientFor']
+      >[0],
+    ) {
+      const url = target.transport === 'auto' ? target.endpoints.http : target.url
+      return url === sourceEndpoint ? source : destination
+    },
+  },
+  auth: { ttlSeconds: 120, resolve: () => ({ credential: 'source-credential' }) },
+  routeStore: new FileSessionRouteStore(routePath),
+  policy: { maximumRouteAgeMs: 60_000 },
+})
+
+try {
+  const value = await session.call(call(target, null))
+  console.log(JSON.stringify({ value, sourceAttempts, destinationAttempts }))
+} finally {
+  session.close()
+  source.close()
+  destination.close()
+}