refactor: share capture binding ownership with transition controls

Author: thymikee

packages/capture-kit/src/durable-capture/index.ts

@@ -23,3 +23,5 @@ export type {
 } from './recovery.ts';
 export type { DurableCaptureRecoveryControl } from './recovery-authority.ts';
 export type { DurableCaptureResourceRecord, DurableCaptureResourceStore } from './store.ts';
+
+export { createDurableCaptureSessionBinding } from './session-binding.ts';

packages/capture-kit/src/durable-capture/session-binding.fixtures.ts

@@ -1,3 +1,4 @@
+import { createDurableCaptureSessionBinding } from './session-binding.ts';
 import { AppError } from '@agent-device/kernel/errors';
 import type { DurableCaptureSessionBinding, DurableCaptureSessionResource } from './definition.ts';
 
@@ -42,46 +43,18 @@ export function makeCaptureSessionBinding<K extends string, H extends AsyncDispo
   }>,
 ): DurableCaptureSessionBinding<K, H> {
   const ref = store.lookup(address);
-  let retained = slot.read(ref.session);
-  const requireSession = (): S => {
-    const session = store.resolveCurrent(ref);
-    if (session === undefined) throw new AppError('COMMAND_FAILED', 'Test session retired');
-    return session;
-  };
-  const assertAdoptable = (): void => {
-    if (slot.read(requireSession())) throw new AppError('COMMAND_FAILED', 'Test resource changed');
-  };
-  return Object.freeze({
+  return createDurableCaptureSessionBinding({
     address,
     sessionDir: store.resolveSessionDir(address),
-    read: () => {
+    initialSession: ref.session,
+    resolveCurrent: () => store.resolveCurrent(ref),
+    requireCurrent: () => {
       const session = store.resolveCurrent(ref);
-      if (session !== undefined) retained = slot.read(session);
-      return retained;
-    },
-    assertAdoptable,
-    canPersist: () => {
-      const session = store.resolveCurrent(ref);
-      return session !== undefined && slot.read(session) === undefined;
-    },
-    adopt: (resource) => {
-      assertAdoptable();
-      store.update(ref, (current) => slot.replace(current, resource));
-      retained = resource;
-    },
-    clear: (expected) => {
-      const current = store.resolveCurrent(ref);
-      if (current === undefined) return 'retired';
-      const active = slot.read(current);
-      if (
-        active?.handle !== expected.handle ||
-        active.envelope.fence.token !== expected.envelope.fence.token ||
-        active.envelope.fence.generation !== expected.envelope.fence.generation
-      )
-        return 'resource-changed';
-      store.update(ref, (session) => slot.replace(session, undefined));
-      retained = undefined;
-      return 'cleared';
+      if (session === undefined) throw new AppError('COMMAND_FAILED', 'Test session retired');
+      return session;
     },
+    assertAdmissionOpen: () => {},
+    read: slot.read,
+    write: (resource) => store.update(ref, (current) => slot.replace(current, resource)),
   });
 }

packages/capture-kit/src/durable-capture/session-binding.test.ts

@@ -0,0 +1,37 @@
+import { expect, test, vi } from 'vitest';
+import { adoptStartedDurableCapture } from './adoption.ts';
+import {
+  makeDurableCaptureContext,
+  makeDurableCaptureStartResult,
+  testCaptureDefinition,
+} from './durable-capture.fixtures.ts';
+import { createDurableCaptureSessionBinding } from './session-binding.ts';
+
+test('closed admission refuses adoption before writing or retaining the resource', async () => {
+  const context = makeDurableCaptureContext();
+  const start = makeDurableCaptureStartResult(context);
+  await adoptStartedDurableCapture(
+    testCaptureDefinition,
+    { ...context, ...start, throwIfCanceled: () => {} },
+    context.resourcePath,
+  );
+  const resource = context.binding.read()!;
+  const session = { capture: undefined };
+  const write = vi.fn();
+  const refusal = new Error('admission closed');
+  const binding = createDurableCaptureSessionBinding({
+    address: context.binding.address,
+    sessionDir: context.binding.sessionDir,
+    initialSession: session,
+    resolveCurrent: () => session,
+    requireCurrent: () => session,
+    assertAdmissionOpen: () => {
+      throw refusal;
+    },
+    read: (current) => current.capture,
+    write,
+  });
+  expect(() => binding.adopt(resource)).toThrow(refusal);
+  expect(write).not.toHaveBeenCalled();
+  expect(binding.read()).toBeUndefined();
+});

packages/capture-kit/src/durable-capture/session-binding.ts

@@ -0,0 +1,59 @@
+import { AppError } from '@agent-device/kernel/errors';
+import type { DurableCaptureSessionBinding, DurableCaptureSessionResource } from './definition.ts';
+
+export function createDurableCaptureSessionBinding<S, K extends string, H extends AsyncDisposable>(
+  port: Readonly<{
+    address: string;
+    sessionDir: string;
+    initialSession: S;
+    resolveCurrent(): S | undefined;
+    requireCurrent(): S;
+    assertAdmissionOpen(): void;
+    read(session: S): DurableCaptureSessionResource<K, H> | undefined;
+    write(resource: DurableCaptureSessionResource<K, H> | undefined): void;
+  }>,
+): DurableCaptureSessionBinding<K, H> {
+  let retained = port.read(port.resolveCurrent() ?? port.initialSession);
+  const assertAdoptable = (): void => {
+    port.assertAdmissionOpen();
+    if (port.read(port.requireCurrent())) {
+      throw new AppError('COMMAND_FAILED', 'Session capture resource has changed', {
+        reason: 'session_resource_changed',
+        session: port.address,
+      });
+    }
+  };
+  return Object.freeze({
+    address: port.address,
+    sessionDir: port.sessionDir,
+    read: () => {
+      const current = port.resolveCurrent();
+      if (current) retained = port.read(current);
+      return retained;
+    },
+    assertAdoptable,
+    canPersist: () => {
+      const current = port.resolveCurrent();
+      return current !== undefined && port.read(current) === undefined;
+    },
+    adopt: (resource) => {
+      assertAdoptable();
+      port.write(resource);
+      retained = resource;
+    },
+    clear: (expected) => {
+      const current = port.resolveCurrent();
+      if (!current) return 'retired';
+      const active = port.read(current);
+      if (
+        active?.handle !== expected.handle ||
+        active.envelope.fence.token !== expected.envelope.fence.token ||
+        active.envelope.fence.generation !== expected.envelope.fence.generation
+      )
+        return 'resource-changed';
+      port.write(undefined);
+      retained = undefined;
+      return 'cleared';
+    },
+  });
+}

src/daemon/session-capture-binding.ts

@@ -1,3 +1,4 @@
+import { createDurableCaptureSessionBinding } from '@agent-device/capture-kit/durable-capture';
 import type {
   DurableCaptureSessionBinding,
   DurableCaptureSessionResource,
@@ -14,48 +15,14 @@ export function bindSessionCapture<K extends string, H extends AsyncDisposable>(
     write(resource: DurableCaptureSessionResource<K, H> | undefined): void;
   }>,
 ): DurableCaptureSessionBinding<K, H> {
-  let retained = slot.read(sessionStore.resolveCurrent(ref) ?? ref.session);
-  const assertAdoptable = (): void => {
-    sessionStore.assertAdmissionOpen(ref.address);
-    if (slot.read(sessionStore.requireCurrent(ref))) {
-      throw new AppError('COMMAND_FAILED', 'Session capture resource has changed', {
-        reason: 'session_resource_changed',
-        session: ref.address,
-      });
-    }
-  };
-  return Object.freeze({
+  return createDurableCaptureSessionBinding({
     address: ref.address,
     sessionDir: sessionStore.resolveSessionDir(ref.address),
-    read: () => {
-      const current = sessionStore.resolveCurrent(ref);
-      if (current) retained = slot.read(current);
-      return retained;
-    },
-    assertAdoptable,
-    canPersist: () => {
-      const current = sessionStore.resolveCurrent(ref);
-      return current !== undefined && slot.read(current) === undefined;
-    },
-    adopt: (resource) => {
-      assertAdoptable();
-      slot.write(resource);
-      retained = resource;
-    },
-    clear: (expected) => {
-      const current = sessionStore.resolveCurrent(ref);
-      if (!current) return 'retired';
-      const active = slot.read(current);
-      if (
-        active?.handle !== expected.handle ||
-        active.envelope.fence.token !== expected.envelope.fence.token ||
-        active.envelope.fence.generation !== expected.envelope.fence.generation
-      )
-        return 'resource-changed';
-      slot.write(undefined);
-      retained = undefined;
-      return 'cleared';
-    },
+    initialSession: ref.session,
+    resolveCurrent: () => sessionStore.resolveCurrent(ref),
+    requireCurrent: () => sessionStore.requireCurrent(ref),
+    assertAdmissionOpen: () => sessionStore.assertAdmissionOpen(ref.address),
+    ...slot,
   });
 }