pi-radar 0.9.0 → 0.10.0

package/extension/radar-children.ts

@@ -1,7 +1,8 @@
+import { randomUUID } from "node:crypto";
 import type { RadarClient, RadarChannelSnapshot, RadarResult } from "./radar-client.ts";
 import type { SpawnListPageSerializePublicSpawnTopology as ListedEdge } from "./generated-contracts.ts";
 import { inspectRadarChild, type RadarInspection } from "./radar-inspection.ts";
-import { observeRadarChild, type RadarChildObservation } from "./radar-launch.ts";
+import { observeRadarChild, waitForChild, launchFailure, type RadarChildObservation, type RadarLaunchOutcome } from "./radar-launch.ts";
 import type { RadarPublication } from "./radar-publication.ts";
 
 const PAGE = 100;
@@ -23,8 +24,25 @@ export type RadarChildAssignment = {
 	retire(): void;
 };
 
+/** The program a restarted child runs as. */
+export type RadarChildProgram = {
+	executable: string;
+	argv: string[];
+	cwd?: string;
+	env?: Record<string, string>;
+};
+
 export type RadarChildren = {
 	list(): Promise<RadarResult<RadarChild[]>>;
+	/**
+	 * Replace this caller's live child with a new process in its own pane and
+	 * session, and wait for the daemon to grant it or withdraw the launch.
+	 */
+	restart(
+		subject: string,
+		program: RadarChildProgram,
+		options?: { pollMs?: number; signal?: AbortSignal },
+	): Promise<RadarLaunchOutcome>;
 	assignment(subject: string, owner: string): RadarChildAssignment;
 	retire(subject: string): void;
 	observe(
@@ -43,8 +61,8 @@ type Resolved = { child: RadarChild; registration_id: string };
  * this surface exists to hide. An edge bound without a subject is not addressable.
  */
 export function createRadarChildren(
-	client: Pick<RadarClient, "spawnList" | "spawnGet" | "agentGet" | "output" | "processInfo">,
-	publication: Pick<RadarPublication, "assignment" | "retireAssignment">,
+	client: Pick<RadarClient, "spawnList" | "spawnGet" | "agentGet" | "output" | "processInfo" | "restart">,
+	publication: Pick<RadarPublication, "assignment" | "retireAssignment" | "subject">,
 ): RadarChildren {
 	const held = new Map<
 		string,
@@ -59,7 +77,7 @@ export function createRadarChildren(
 			if (read.ok === false) return read;
 			for (const edge of read.value.spawns as ListedEdge[]) {
 				const bound = edge.bound;
-				if (!bound?.subject_id || !bound.registration_id || edge.launched !== "completed") continue;
+				if (!bound?.subject_id || !bound.registration_id || edge.granted_at == null || edge.withdrawn != null) continue;
 				const at = Date.parse(bound.bound_at);
 				if (Number.isNaN(at)) continue;
 				const current = newest.get(bound.subject_id);
@@ -114,6 +132,34 @@ export function createRadarChildren(
 			follow(all.value);
 			return { ok: true, value: [...all.value.values()].map((entry) => entry.child) };
 		},
+		async restart(subject, program, options) {
+			const parent = await publication.subject();
+			if (parent?.subject_id === undefined)
+				return { kind: "failed", message: "this process has no Radar registration to restart a child under" };
+			const request_id = randomUUID();
+			const requested = await client.restart({
+				request_id,
+				parent: parent.registration_id,
+				subject_id: subject,
+				...program,
+			});
+			if (requested.ok === false)
+				return launchFailure(requested, request_id);
+			const bound = await waitForChild(client, requested.value.launch_request_id, {
+				pollMs: options?.pollMs ?? 250,
+				...(options?.signal !== undefined ? { signal: options.signal } : {}),
+			});
+			if (bound.kind !== "bound") return bound;
+			await resolveAndFollow(subject);
+			return {
+				kind: "ready",
+				value: {
+					request_id: requested.value.launch_request_id,
+					subject_id: bound.subject_id,
+					pane_id: bound.pane_id,
+				},
+			};
+		},
 		assignment(subject, owner) {
 			const existing = held.get(subject);
 			if (existing !== undefined) return existing.writer;

package/extension/radar-client.ts

@@ -38,7 +38,7 @@ export const RADAR_PROTOCOL_VERSION = 2;
  * parent continue or restart its own child by subject.
  * Earlier daemons expose different identity fields; require a coordinated update.
  */
-export const RADAR_MINIMUM_REVISION = 7;
+export const RADAR_MINIMUM_REVISION = 8;
 /** Public daemon contracts this client may preflight. */
 export const RADAR_REGISTRY_CONTRACT = "registry.v1";
 export const RADAR_REGISTRY_FACTS_CONTRACT = "registry.facts.v1";
@@ -309,6 +309,9 @@ export type RadarSpawnEdge = {
 	location?: RadarLocation;
 	bound?: { source: string; incarnation: string; registration_id?: string; subject_id?: string };
 	exit_observation?: RadarSpawnExitObservation;
+	/** Set when the daemon withdrew the launch before its process presented. */
+	withdrawn?: { at: string; reason: string };
+	granted_at?: string;
 };
 
 /**
@@ -830,6 +833,9 @@ function spawnEdge(value: unknown): RadarResult<RadarSpawnEdge> {
 	const agentId = stringAt(bound, "registration_id");
 	const subjectId = stringAt(bound, "subject_id");
 	const exit = exitAt(recordAt(value, "exit_observation"));
+	const withdrawnRecord = recordAt(value, "withdrawn");
+	const withdrawnAt = stringAt(withdrawnRecord, "at");
+	const withdrawnReason = stringAt(withdrawnRecord, "reason");
 	return {
 		ok: true,
 		value: {
@@ -849,6 +855,10 @@ function spawnEdge(value: unknown): RadarResult<RadarSpawnEdge> {
 					}
 				: {}),
 			...(exit !== undefined ? { exit_observation: exit } : {}),
+			...(stringAt(value, "granted_at") !== undefined ? { granted_at: stringAt(value, "granted_at") } : {}),
+			...(withdrawnAt !== undefined && withdrawnReason !== undefined
+				? { withdrawn: { at: withdrawnAt, reason: withdrawnReason } }
+				: {}),
 		},
 	};
 }
@@ -1124,7 +1134,7 @@ export type RadarClient = {
 		argv: string[];
 		cwd?: string;
 		env?: Record<string, string>;
-	}): Promise<RadarResult<{ request_id: string }>>;
+	}): Promise<RadarResult<{ request_id: string; launch_request_id: string }>>;
 	/** List launches owned by this client's registered process. */
 	spawnList(request: Pick<SpawnListParamsDeserialize, "after" | "limit">): Promise<RadarResult<SpawnListPageSerialize>>;
 	spawnGet(request_id: string): Promise<RadarResult<RadarSpawnTopology>>;
@@ -1757,7 +1767,11 @@ export function createRadarClient(options: RadarClientOptions = {}): RadarClient
 					request.request_id,
 				);
 				if (answer.ok === false) return answer;
-				return focusOutcome(recordAt(answer.value, "request"), request.request_id);
+				const settled = focusOutcome(recordAt(answer.value, "request"), request.request_id);
+				if (settled.ok === false) return settled;
+				const launch = recordAt(recordAt(answer.value, "request"), "launch_request_id");
+				if (!isUuid(launch)) return protocol("lifecycle.restart reply names no launch");
+				return { ok: true, value: { ...settled.value, launch_request_id: launch } };
 			});
 		},
 		async spawnList(request) {

package/extension/radar-launch.ts

@@ -5,72 +5,15 @@ import {
 	type RadarErrorCode,
 	type RadarLocation,
 	type RadarResult,
-	type RadarSpawnEdge,
 } from "./radar-client.ts";
-import { radarPaneHandle } from "./radar-location.ts";
 import type { RadarPublication } from "./radar-publication.ts";
 
-/** The startup acknowledgement a launch waits for, named by its identity. */
-export type StartupExpectation = {
-	generation: string;
-	runId: string;
-	ownerSessionId: string;
-	workspaceId: string;
-	agentLabel: string;
-	paneId: string;
-};
-
-/**
- * The mailbox readers a launch needs. The mailbox belongs to the caller (Herdsman
- * supplies its own state shape and readers); this module only takes the path it
- * is handed and asks these questions of it.
- */
-export type LaunchState = { paneId: string };
-
-export type LaunchMailbox<State extends LaunchState> = {
-	readState(path: string): State | undefined;
-	waitForState(
-		path: string,
-		predicate: (state: State) => boolean,
-		options: { timeoutMs: number; signal?: AbortSignal },
-	): Promise<State>;
-	startupAckMatches(state: State | undefined, expected: StartupExpectation): boolean;
-};
-
-/**
- * Launching one fresh managed worker through Radar's spawn operation.
- *
- * A spawn is one durable effect behind the caller's own request UUID, and three
- * separate facts decide whether a child can take an assignment:
- *
- * 1. the daemon created a pane under this process's registered pane, launched
- *    the child's exact command into it, and still reports that pane in its own
- *    inventory;
- * 2. a child registered with the launch's private token, so the edge names the
- *    exact `registration_id` that child obtained — never a label, pane or session;
- * 3. that child wrote a fresh startup acknowledgment for this launch generation
- *    after Herdsman startup finished, naming the pane the daemon created as its
- *    own location.
- *
- * Only the third is application readiness; the first two are prerequisites. A
- * lost reply is reconciled against the same request UUID and never re-sent, so a
- * failed launch cannot leave a second pane or a second child behind.
- *
- * The child's location is a fact about the pane the daemon created, not about
- * the environment it was launched with: the daemon passes an environment overlay
- * to a mux-created pane and cannot remove what that pane already carries, so a
- * child that inherited its parent's pane coordinates would claim the parent's
- * pane. The daemon's fresh record of the created pane and the child's own claim
- * must therefore name the same pane, and either one being stale, missing or
- * different leaves the launch unresolved rather than placed.
- */
+/** A launch succeeds when Radar grants its child's verified first presence. */
 
 /** Everything one fresh managed worker is launched with. */
 export type RadarWorkerLaunch = {
 	/** The caller's durable key, persisted before dispatch and never replaced. */
 	request_id: string;
-	/** The nonce the child must repeat in its startup acknowledgment. */
-	generation: string;
 	/**
 	 * Start this released child agent again rather than a new one. The daemon takes
 	 * the session from its own record, so no session id or path is sent.
@@ -87,33 +30,24 @@ export type RadarWorkerLaunch = {
 	cwd: string;
 	/** The environment overlay the child needs, not a replacement environment. */
 	env: Record<string, string>;
-	/** The child's mailbox: its own state is the readiness evidence. */
-	mailbox: string;
-	/** The identity the child's state and acknowledgment must repeat exactly. */
-	identity: {
-		runId: string;
-		ownerSessionId: string;
-		workspaceId: string;
-		agentLabel: string;
-	};
 };
 
-export type RadarWorkerLaunched<State = unknown> = {
+export type RadarWorkerLaunched = {
 	request_id: string;
 	/** The child's durable identity: the key that survives its restart and resume. */
 	subject_id: string;
 	pane_id: string;
-	state: State;
 };
 
 /**
- * `refused` is a launch that provably did not begin; `unresolved` is one whose
- * pane, child or readiness cannot be established, which the caller reports
- * rather than retries.
+ * `ready` is a child whose first presence the daemon granted. `failed` is a launch
+ * the daemon withdrew (or that provably never began), so a retry is safe.
+ * `unresolved` is the rare launch whose outcome cannot be read at all, which the
+ * caller reports rather than retries.
  */
-export type RadarLaunchOutcome<State = unknown> =
-	| { kind: "ready"; value: RadarWorkerLaunched<State> }
-	| { kind: "refused"; message: string }
+export type RadarLaunchOutcome =
+	| { kind: "ready"; value: RadarWorkerLaunched }
+	| { kind: "failed"; message: string }
 	| { kind: "unresolved"; request_id: string; message: string };
 
 /**
@@ -158,8 +92,8 @@ function trajectory(reason: string): string {
  *
  * The durable spawn record and the child's own binding say *which* subject this
  * launch created; they are provenance, not liveness, and they stay true after a
- * child is gone. The startup acknowledgment says the child is ready, which is
- * also not liveness. Only a current topology read decides: `bound` has to name
+ * child is gone. A presence grant is startup evidence, not perpetual liveness.
+ * Only a current topology read decides: `bound` has to name
  * the same subject, the read has to record the pane this launch claims, no
  * process exit may have been observed, and the read's own `freshness` has to
  * report that the daemon's inventory currently places that pane. Anything else -
@@ -293,26 +227,25 @@ export async function relaunchRefusalForChild(
 	return `the child's registered process is ${verification === "verified" ? "still running" : "not proved gone"}`;
 }
 
-export type RadarLaunchOptions<State extends LaunchState = LaunchState> = {
+export type RadarLaunchOptions = {
 	client: RadarClient;
 	/** This process's own publication, which names the parent of the launch. */
 	publication: Pick<RadarPublication, "subject">;
-	readers: LaunchMailbox<State>;
 	launch: RadarWorkerLaunch;
-	timeoutMs: number;
-	/** How often the binding and readiness waits re-read; 0 in driven tests. */
+	/** How often the wait re-reads the launch; 0 in driven tests. */
 	pollMs?: number;
+	/** Stops the wait. The daemon's own deadline still withdraws the launch. */
 	signal?: AbortSignal;
 };
 
-function refusedLaunch(message: string): Extract<RadarLaunchOutcome, { kind: "refused" | "unresolved" }> {
-	return { kind: "refused", message };
+function refusedLaunch(message: string): Extract<RadarLaunchOutcome, { kind: "failed" | "unresolved" }> {
+	return { kind: "failed", message };
 }
 
 function unresolvedLaunch(
 	requestId: string,
 	message: string,
-): Extract<RadarLaunchOutcome, { kind: "refused" | "unresolved" }> {
+): Extract<RadarLaunchOutcome, { kind: "failed" | "unresolved" }> {
 	return {
 		kind: "unresolved",
 		request_id: requestId,
@@ -320,19 +253,6 @@ function unresolvedLaunch(
 	};
 }
 
-/** Whether the edge's own two effects already prove a launch happened. */
-function edgeStanding(edge: RadarSpawnEdge): "launched" | "refused" | "unknown" {
-	if (edge.created === "refused" || edge.launched === "refused")
-		return "refused";
-	return edge.created === "completed" && edge.launched === "completed"
-		? "launched"
-		: "unknown";
-}
-
-function edgeMessage(edge: RadarSpawnEdge): string {
-	return `the daemon's spawn record is created ${edge.created} and launched ${edge.launched}`;
-}
-
 /**
  * The daemon's own refusals, which prove no effect was dispatched. Every other
  * failure — a lost reply, a timeout, an internal error, an unreadable answer —
@@ -353,27 +273,24 @@ const PRE_EFFECT_CODES: readonly RadarErrorCode[] = [
 	"backend_unavailable",
 ];
 
-function spawnFailure(
-	result: Extract<RadarResult<RadarSpawnEdge>, { ok: false }>,
+export function launchFailure(
+	result: Extract<RadarResult<unknown>, { ok: false }>,
 	requestId: string,
-): Extract<RadarLaunchOutcome, { kind: "refused" | "unresolved" }> {
+): Extract<RadarLaunchOutcome, { kind: "failed" | "unresolved" }> {
 	return PRE_EFFECT_CODES.includes(result.code)
 		? refusedLaunch(result.message)
 		: unresolvedLaunch(requestId, result.message);
 }
 
 /**
- * Wait for the child's own registration to bind this edge, then for its startup
- * acknowledgment. The edge is re-read by the same request UUID: a spawn that
- * already answered is never sent again.
+ * Wait for the child's verified presence grant or the daemon's withdrawal. The
+ * same request UUID is read throughout; a lost reply never starts another child.
  */
-export async function launchRadarWorker<State extends LaunchState>(
-	options: RadarLaunchOptions<State>,
-): Promise<RadarLaunchOutcome<State>> {
+export async function launchRadarWorker(
+	options: RadarLaunchOptions,
+): Promise<RadarLaunchOutcome> {
 	const { client, launch, signal } = options;
 	const pollMs = options.pollMs ?? 250;
-	const deadline = Date.now() + options.timeoutMs;
-	const remaining = (): number => Math.max(0, deadline - Date.now());
 	const parent = await options.publication.subject();
 	if (parent === undefined || !isUuid(parent.registration_id))
 		return refusedLaunch(
@@ -408,87 +325,46 @@ export async function launchRadarWorker<State extends LaunchState>(
 		...(Object.keys(launch.env).length > 0 ? { env: launch.env } : {}),
 	});
 	if (spawned.ok === false) {
-		const refusal = spawnFailure(spawned, launch.request_id);
-		if (refusal.kind === "refused") return refusal;
-	}
-	if (spawned.ok === true) {
-		const standing = edgeStanding(spawned.value);
-		if (standing === "refused")
-			return refusedLaunch(edgeMessage(spawned.value));
-		if (standing === "unknown")
-			return unresolvedLaunch(launch.request_id, edgeMessage(spawned.value));
+		const refusal = launchFailure(spawned, launch.request_id);
+		if (refusal.kind === "failed") return refusal;
 	}
 
 	const bound = await waitForChild(client, launch.request_id, {
-		remaining,
 		pollMs,
 		...(signal !== undefined ? { signal } : {}),
 	});
 	if (bound.kind !== "bound") return bound;
-	const agentId = bound.registration_id;
-	try {
-		const state = await options.readers.waitForState(
-			launch.mailbox,
-			(candidate) =>
-				options.readers.startupAckMatches(candidate, {
-					generation: launch.generation,
-					runId: launch.identity.runId,
-					ownerSessionId: launch.identity.ownerSessionId,
-					workspaceId: launch.identity.workspaceId,
-					agentLabel: launch.identity.agentLabel,
-						// The child writes the raw TMUX_PANE of the pane it runs in. Requiring
-						// the pane the daemon created is what refuses a child that inherited
-						// another process's coordinates.
-					paneId: radarPaneHandle(bound.pane_id),
-				}),
-			{ timeoutMs: remaining(), ...(signal !== undefined ? { signal } : {}) },
-		);
-		return {
-			kind: "ready",
-			value: {
-				request_id: launch.request_id,
-				subject_id: bound.subject_id,
-				pane_id: bound.pane_id,
-				state,
-			},
-		};
-	} catch (error) {
-		const claimed = options.readers.readState(launch.mailbox)?.paneId;
-		return unresolvedLaunch(
-			launch.request_id,
-			claimed !== undefined && claimed !== radarPaneHandle(bound.pane_id)
-				? `the bound child ${agentId} claims the pane ${claimed}, not the pane ${bound.pane_id} this launch created for it`
-				: `the bound child ${agentId} has not acknowledged this launch's startup (${String(error)})`,
-		);
-	}
+	return {
+		kind: "ready",
+		value: {
+			request_id: launch.request_id,
+			subject_id: bound.subject_id,
+			pane_id: bound.pane_id,
+		},
+	};
 }
 
 type BoundChild =
 	| {
 			kind: "bound";
 			subject_id: string;
-			registration_id: string;
 			pane_id: string;
-			source: string;
-			incarnation: string;
 	  }
-	| Extract<RadarLaunchOutcome, { kind: "refused" | "unresolved" }>;
+	| Extract<RadarLaunchOutcome, { kind: "failed" | "unresolved" }>;
 
 /**
- * Poll the edge this request id authored until a child presents its token.
+ * Poll the edge this request id authored until the daemon grants its child or
+ * withdraws the launch. There is no timeout here: the daemon owns the deadline and
+ * records a withdrawal on the edge, so waiting longer than it would only wait for
+ * an outcome that is already decided.
  *
- * The daemon binds the edge once, to the exact registration the token produced,
- * so `bound.registration_id` is the child identity. A refusal or an unknown launch
- * effect ends the wait at once: neither becomes a child by waiting longer. An
- * edge whose recorded pane the daemon no longer reports ends it too: waiting
- * cannot create the pane a launch claims, and a location read afterwards would
- * be that of whatever moved in.
+ * Registration binding alone is not success: a pending or duplicate presence
+ * can bind an edge without ever acquiring attachment authority.
  */
-async function waitForChild(
-	client: RadarClient,
+export async function waitForChild(
+	client: Pick<RadarClient, "spawnGet">,
 	requestId: string,
 	options: {
-		remaining: () => number;
 		pollMs: number;
 		signal?: AbortSignal;
 	},
@@ -499,53 +375,22 @@ async function waitForChild(
 			return unresolvedLaunch(requestId, `the launch was cancelled (${last})`);
 		const answer = await client.spawnGet(requestId);
 		if (answer.ok === true) {
-			const { edge, state, freshness } = answer.value;
-			const standing = edgeStanding(edge);
-			if (standing === "refused")
-				return refusedLaunch(`${edgeMessage(edge)}`);
-			if (standing === "unknown")
-				return unresolvedLaunch(requestId, edgeMessage(edge));
+			const { edge } = answer.value;
+			if (edge.withdrawn !== undefined)
+				return refusedLaunch(`the daemon withdrew this launch: ${edge.withdrawn.reason}`);
+			if (edge.granted_at === undefined) {
+				await delay(options.pollMs);
+				continue;
+			}
 			const pane = edge.location?.pane;
 			if (pane === undefined || pane === "")
 				return unresolvedLaunch(
 					requestId,
 					"the daemon's launch recorded no pane to verify the child against",
 				);
-			// The recorded pane is the daemon's own statement about where it created
-			// and launched this child, and `fresh` is its inventory confirming that
-			// pane right now. Without that confirmation the launch has no verified
-			// location to give the child, and no later read can supply one.
-			if (freshness !== "fresh")
-				return unresolvedLaunch(
-					requestId,
-					state === "unresolved"
-						? `the daemon's inventory does not report the pane ${pane} its own record names for this child`
-						: `the daemon cannot confirm the pane ${pane} it recorded for this child`,
-				);
-			// An observed exit is the child's process, and a pane's shell can outlive it.
-			if (edge.exit_observation?.state === "exited")
-				return unresolvedLaunch(
-					requestId,
-					"the daemon observed the launched child's process exit",
-				);
+
 			const agentId = edge.bound?.registration_id;
 			if (agentId !== undefined && isUuid(agentId)) {
-				// A child the daemon bound without the process it registered as is a
-				// child no assignment can be addressed to, and an unaddressed Radar
-				// assignment is exactly what addressing exists to prevent: the launch
-				// stays unresolved rather than degrading to a V5 request.
-				const source = edge.bound?.source;
-				const incarnation = edge.bound?.incarnation;
-				if (
-					source === undefined ||
-					source === "" ||
-					incarnation === undefined ||
-					incarnation === ""
-				)
-					return unresolvedLaunch(
-						requestId,
-						`the daemon bound the child ${agentId} without recording the process it registered as`,
-					);
 				// The edge names the agent as well as its process. Without it the child
 				// has no durable key to be returned by, and a registration is never
 				// offered in its place.
@@ -558,20 +403,13 @@ async function waitForChild(
 				return {
 					kind: "bound",
 					subject_id: subjectId,
-					registration_id: agentId,
 					pane_id: pane,
-					source,
-					incarnation,
 				};
 			}
 			last = "no child has registered with this launch's token yet";
 		} else {
-			last = answer.message;
+			return unresolvedLaunch(requestId, answer.message);
 		}
-		if (options.remaining() <= 0)
-			return unresolvedLaunch(requestId, last);
-		await delay(options.pollMs, undefined, {
-			...(options.signal !== undefined ? { signal: options.signal } : {}),
-		});
+		await delay(options.pollMs);
 	}
 }

package/extension/radar-runtime.ts

@@ -5,7 +5,7 @@ import type { RadarPublication } from "./radar-publication.ts";
 
 /** The event channel through which Pi extensions obtain the baseline runtime. */
 export const RADAR_RUNTIME_REQUEST = "pi-radar/runtime-request";
-export const RADAR_RUNTIME_VERSION = 3 as const;
+export const RADAR_RUNTIME_VERSION = 4 as const;
 
 /** The sole baseline publisher's session-scoped runtime, shared with consumers. */
 export type RadarRuntimeServices = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-radar",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "type": "module",
   "description": "Radar daemon client, communication, publication, execution, location, launch and inspection surface for Pi extensions.",
   "license": "Apache-2.0",

package/schema/public/v1/observation-get-response.deserialize.schema.json

@@ -893,12 +893,6 @@
         },
         "subject_id": {
           "type": "string"
-        },
-        "successor": {
-          "type": [
-            "string",
-            "null"
-          ]
         }
       },
       "required": [
@@ -1060,12 +1054,6 @@
         },
         "subject_id": {
           "type": "string"
-        },
-        "successor": {
-          "type": [
-            "string",
-            "null"
-          ]
         }
       },
       "required": [

package/schema/public/v1/observation-get-response.serialize.schema.json

@@ -941,12 +941,6 @@
         },
         "subject_id": {
           "type": "string"
-        },
-        "successor": {
-          "type": [
-            "string",
-            "null"
-          ]
         }
       },
       "required": [
@@ -954,8 +948,7 @@
         "bound_registration_id",
         "process",
         "state",
-        "session",
-        "successor"
+        "session"
       ],
       "type": "object"
     },
@@ -1119,12 +1112,6 @@
         },
         "subject_id": {
           "type": "string"
-        },
-        "successor": {
-          "type": [
-            "string",
-            "null"
-          ]
         }
       },
       "required": [
@@ -1135,8 +1122,7 @@
         "metadata",
         "child_close",
         "state",
-        "session",
-        "successor"
+        "session"
       ],
       "type": "object"
     },

package/schema/public/v1/observation-snapshot.deserialize.schema.json

@@ -893,12 +893,6 @@
         },
         "subject_id": {
           "type": "string"
-        },
-        "successor": {
-          "type": [
-            "string",
-            "null"
-          ]
         }
       },
       "required": [
@@ -1060,12 +1054,6 @@
         },
         "subject_id": {
           "type": "string"
-        },
-        "successor": {
-          "type": [
-            "string",
-            "null"
-          ]
         }
       },
       "required": [