pi-radar 0.1.0 → 0.2.0

package/extension/radar-publication.ts

@@ -14,6 +14,7 @@ import {
 } from "node:fs";
 import { dirname, isAbsolute, join, parse, resolve, sep } from "node:path";
 import type { RadarLocationResolution } from "./radar-location.ts";
+import { decodeRadarLaunchMarker } from "./radar-session-marker.ts";
 import {
 	boundedRadarAssignment,
 	boundedRadarFacts,
@@ -27,6 +28,7 @@ import {
 	type RadarFactsSnapshot,
 	type RadarClient,
 	type RadarLocation,
+	type RadarLaunchIdentityMarker,
 	type RadarPublisherIdentity,
 	type RadarRegistration,
 	type RadarScheduler,
@@ -323,6 +325,7 @@ type ContextReport = {
 	session: string | null;
 	lease_ms: number;
 	observed_at: string;
+	launch_identity?: RadarLaunchIdentityMarker;
 };
 
 /**
@@ -560,7 +563,9 @@ function pendingAt(
 }
 
 const CONTEXT_PENDING_KEYS = "lease_ms,observed_at,sequence,session";
+const CONTEXT_PENDING_MARKED_KEYS = "launch_identity,lease_ms,observed_at,sequence,session";
 const CONTEXT_ACCEPTED_KEYS = "lease_ms,observed_at,sent_at,sequence,session";
+const CONTEXT_ACCEPTED_MARKED_KEYS = "launch_identity,lease_ms,observed_at,sent_at,sequence,session";
 
 /** The reported session, or `undefined` when the field is not one of the two. */
 function sessionAt(value: unknown): string | null | undefined {
@@ -570,11 +575,28 @@ function sessionAt(value: unknown): string | null | undefined {
 	return typeof found === "string" ? found : undefined;
 }
 
+function sameLaunchIdentity(
+	a: RadarLaunchIdentityMarker | undefined,
+	b: RadarLaunchIdentityMarker | undefined,
+): boolean {
+	return (
+		a === b ||
+		(a !== undefined &&
+			b !== undefined &&
+			a.version === b.version &&
+			a.subject_id === b.subject_id &&
+			a.launch_id === b.launch_id &&
+			a.execution_generation === b.execution_generation)
+	);
+}
+
 function contextReportAt(
 	value: unknown,
 	keys: string,
+	markedKeys: string,
 ): ContextReport | undefined {
-	if (!exactKeys(value, keys)) return undefined;
+	const marked = exactKeys(value, markedKeys);
+	if (!exactKeys(value, keys) && !marked) return undefined;
 	const sequence = numberAt(value, "sequence");
 	const lease = numberAt(value, "lease_ms");
 	const observed = textAt(value, "observed_at");
@@ -582,7 +604,17 @@ function contextReportAt(
 	if (sequence === undefined || sequence < 1) return undefined;
 	if (lease === undefined || observed === undefined || session === undefined)
 		return undefined;
-	return { sequence, session, lease_ms: lease, observed_at: observed };
+	const marker = marked
+		? decodeRadarLaunchMarker((value as Record<string, unknown>).launch_identity)
+		: undefined;
+	if (marked && marker === undefined) return undefined;
+	return {
+		sequence,
+		session,
+		lease_ms: lease,
+		observed_at: observed,
+		...(marker !== undefined ? { launch_identity: marker } : {}),
+	};
 }
 
 export type RadarFactsWriter = Omit<RadarChannelWriter, "update"> & {
@@ -939,7 +971,7 @@ export type RadarContextWriter = {
 	 * session" the daemon serves; `undefined` never is, because a process that
 	 * does not know its session has nothing to assert.
 	 */
-	update(session: string | null): void;
+	update(session: string | null, launchIdentity?: RadarLaunchIdentityMarker): void;
 	/** Release this writer's timers. The accepted report stays until it goes stale. */
 	stop(): void;
 	/** Re-arm a stopped writer after an extension reload. */
@@ -977,6 +1009,7 @@ function createContextWriter(input: ContextWriterInput): RadarContextWriter {
 	const { store, client, scheduler, recordName, publisher } = input;
 	let record = loadRecord();
 	let desired: string | null | undefined;
+	let desiredMarker: RadarLaunchIdentityMarker | undefined;
 	let running = false;
 	let again = false;
 	let recovering = false;
@@ -1016,9 +1049,17 @@ function createContextWriter(input: ContextWriterInput): RadarContextWriter {
 			(!exactKeys(writer, WRITER_KEYS) || !isUuid(handle) || generation === undefined)
 		)
 			return blank(agentId);
-		const pending = contextReportAt(recordAt(value, "pending"), CONTEXT_PENDING_KEYS);
+		const pending = contextReportAt(
+			recordAt(value, "pending"),
+			CONTEXT_PENDING_KEYS,
+			CONTEXT_PENDING_MARKED_KEYS,
+		);
 		const acceptedValue = recordAt(value, "accepted");
-		const accepted = contextReportAt(acceptedValue, CONTEXT_ACCEPTED_KEYS);
+		const accepted = contextReportAt(
+			acceptedValue,
+			CONTEXT_ACCEPTED_KEYS,
+			CONTEXT_ACCEPTED_MARKED_KEYS,
+		);
 		const sentAt = numberAt(acceptedValue, "sent_at");
 		return {
 			version: RADAR_PUBLICATION_VERSION,
@@ -1100,7 +1141,12 @@ function createContextWriter(input: ContextWriterInput): RadarContextWriter {
 			sequence: pending.sequence,
 			lease_ms: pending.lease_ms,
 			observed_at: pending.observed_at,
-			context: { session: pending.session },
+			context: {
+			session: pending.session,
+			...(pending.launch_identity !== undefined
+				? { launch_identity: pending.launch_identity }
+				: {}),
+		},
 		});
 		if (answer.ok === true) {
 			recovering = false;
@@ -1144,12 +1190,16 @@ function createContextWriter(input: ContextWriterInput): RadarContextWriter {
 		// silently advance.
 	}
 
-	async function stage(session: string | null): Promise<void> {
+	async function stage(
+		session: string | null,
+		launchIdentity?: RadarLaunchIdentityMarker,
+	): Promise<void> {
 		const pending: ContextReport = {
 			sequence: record.sequence + 1,
 			session,
 			lease_ms: input.leaseMs,
 			observed_at: new Date(scheduler.now()).toISOString(),
+			...(launchIdentity !== undefined ? { launch_identity: launchIdentity } : {}),
 		};
 		// Persisted before it is sent, so a lost reply replays this exact request.
 		record.pending = pending;
@@ -1170,12 +1220,13 @@ function createContextWriter(input: ContextWriterInput): RadarContextWriter {
 		if (
 			record.writer === undefined ||
 			record.accepted === undefined ||
-			record.accepted.session !== desired
+			record.accepted.session !== desired ||
+			!sameLaunchIdentity(record.accepted.launch_identity, desiredMarker)
 		) {
-			await stage(desired);
+			await stage(desired, desiredMarker);
 			return;
 		}
-		if (heartbeatDue()) await stage(record.accepted.session);
+		if (heartbeatDue()) await stage(record.accepted.session, desiredMarker);
 	}
 
 	async function drain(): Promise<void> {
@@ -1211,12 +1262,18 @@ function createContextWriter(input: ContextWriterInput): RadarContextWriter {
 	}
 
 	return {
-		update(session) {
-			if (fenced || session === desired) return;
+		update(session, launchIdentity) {
+			if (
+				fenced ||
+				(session === desired &&
+					sameLaunchIdentity(desiredMarker, launchIdentity))
+			)
+				return;
 			// A session reported while this writer is stopped is remembered, not
 			// published: only `reopen` restarts the timers, and it must see the
 			// session the process is in now rather than the one it left.
 			desired = session;
+			desiredMarker = launchIdentity;
 			if (stopped) return;
 			kick();
 		},

package/extension/radar-runtime.ts

@@ -0,0 +1,94 @@
+import type { RadarExecutionAdapter } from "./radar-execution.ts";
+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 = 1 as const;
+
+/** The sole baseline publisher's session-scoped runtime, shared with consumers. */
+export type RadarRuntimeServices = {
+	/** The one baseline publication; Herdsman contributes through its channels. */
+	publication: RadarPublication;
+	execution: RadarExecutionAdapter;
+};
+
+/** Lazy so discovering the provider in an extension factory starts no resources. */
+export type RadarRuntimeHandle = {
+	version: typeof RADAR_RUNTIME_VERSION;
+	/** Provider memoizes this promise, so every extension shares one publisher. */
+	start(): Promise<RadarRuntimeServices>;
+};
+
+/** Builds one lazy, memoized session runtime without starting factory resources. */
+export function lazyRadarRuntime(
+	start: () => RadarRuntimeServices | Promise<RadarRuntimeServices>,
+): RadarRuntimeHandle {
+	let pending: Promise<RadarRuntimeServices> | undefined;
+	return {
+		version: RADAR_RUNTIME_VERSION,
+		start: () => (pending ??= Promise.resolve().then(start)),
+	};
+}
+
+/** Minimal structural view of Pi's shared extension EventBus. */
+export type RadarExtensionEventBus = {
+	emit(channel: string, data: unknown): void;
+	on(channel: string, handler: (data: unknown) => void): () => void;
+};
+
+type RuntimeRequest = {
+	version: typeof RADAR_RUNTIME_VERSION;
+	provide(handle: unknown): void;
+};
+
+/**
+ * Makes this extension's handle discoverable to other extensions in this Pi
+ * runtime. Registering the listener is safe in a factory: it starts no resources.
+ */
+export function provideRadarRuntime(
+	events: RadarExtensionEventBus,
+	handle: RadarRuntimeHandle,
+): () => void {
+	return events.on(RADAR_RUNTIME_REQUEST, (value) => {
+		if (!isRuntimeRequest(value)) return;
+		value.provide(handle);
+	});
+}
+
+/**
+ * Finds the one baseline runtime in the current Pi process. Pi's event bus emits
+ * synchronously; the reply callback therefore completes before this returns.
+ * Zero or multiple providers are explicit errors, not invitations to register a
+ * second baseline publisher.
+ */
+export function requestRadarRuntime(
+	events: RadarExtensionEventBus,
+): { ok: true; handle: RadarRuntimeHandle } | { ok: false; reason: "missing" | "duplicate" } {
+	const handles: RadarRuntimeHandle[] = [];
+	events.emit(RADAR_RUNTIME_REQUEST, {
+		version: RADAR_RUNTIME_VERSION,
+		provide: (candidate: unknown) => {
+			if (isRadarRuntimeHandle(candidate)) handles.push(candidate);
+		},
+	} satisfies RuntimeRequest);
+	if (handles.length === 1) return { ok: true, handle: handles[0] };
+	return { ok: false, reason: handles.length === 0 ? "missing" : "duplicate" };
+}
+
+function isRuntimeRequest(value: unknown): value is RuntimeRequest {
+	return (
+		typeof value === "object" &&
+		value !== null &&
+		(value as RuntimeRequest).version === RADAR_RUNTIME_VERSION &&
+		typeof (value as RuntimeRequest).provide === "function"
+	);
+}
+
+function isRadarRuntimeHandle(value: unknown): value is RadarRuntimeHandle {
+	if (typeof value !== "object" || value === null) return false;
+	const handle = value as Partial<RadarRuntimeHandle>;
+	return (
+		handle.version === RADAR_RUNTIME_VERSION &&
+		typeof handle.start === "function"
+	);
+}

package/extension/radar-session-marker.ts

@@ -0,0 +1,146 @@
+/**
+ * Radar-issued identity carried as a non-context custom entry in the active Pi
+ * session branch. It is a recovery breadcrumb, not an authority to create or
+ * mutate a Radar subject.
+ */
+import type { LaunchIdentityMarkerSerialize } from "./generated-contracts.ts";
+
+export const RADAR_LAUNCH_MARKER_TYPE = "pi-radar.launch-identity";
+export const RADAR_LAUNCH_MARKER_VERSION = 1 as const;
+export const RADAR_MAX_EXECUTION_GENERATION = 0xffff_ffff;
+
+export type RadarLaunchMarker = Omit<LaunchIdentityMarkerSerialize, "version"> & {
+	version: typeof RADAR_LAUNCH_MARKER_VERSION;
+};
+
+/** Structural subset of Pi's custom SessionEntry used by this codec. */
+export type CustomSessionEntry = {
+	type: string;
+	customType?: string;
+	data?: unknown;
+};
+
+/** pi.appendEntry-compatible callback; no Pi runtime import is needed here. */
+export type AppendSessionEntry = (customType: string, data?: unknown) => void;
+export type PiSessionMarkerHost = {
+	appendEntry?: AppendSessionEntry;
+	sessionManager?: { getBranch(): readonly CustomSessionEntry[] };
+};
+
+export const RADAR_MANAGED_SUBJECT_ENV = "PI_RADAR_MANAGED_SUBJECT_ID";
+export const RADAR_MANAGED_LAUNCH_ENV = "PI_RADAR_MANAGED_LAUNCH_ID";
+export const RADAR_MANAGED_GENERATION_ENV = "PI_RADAR_MANAGED_EXECUTION_GENERATION";
+
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
+
+/** Validates the exact versioned marker shape before writing or accepting it. */
+export function decodeRadarLaunchMarker(value: unknown): RadarLaunchMarker | undefined {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return undefined;
+	const record = value as Record<string, unknown>;
+	if (
+		Object.keys(record).sort().join(",") !==
+		"execution_generation,launch_id,subject_id,version"
+	) {
+		return undefined;
+	}
+	if (
+		record.version !== RADAR_LAUNCH_MARKER_VERSION ||
+		typeof record.subject_id !== "string" ||
+		!UUID.test(record.subject_id) ||
+		typeof record.launch_id !== "string" ||
+		!UUID.test(record.launch_id) ||
+		!Number.isSafeInteger(record.execution_generation) ||
+		(record.execution_generation as number) < 1 ||
+		(record.execution_generation as number) > RADAR_MAX_EXECUTION_GENERATION
+	) {
+		return undefined;
+	}
+	return {
+		version: RADAR_LAUNCH_MARKER_VERSION,
+		subject_id: record.subject_id,
+		launch_id: record.launch_id,
+		execution_generation: record.execution_generation as number,
+	};
+}
+
+/** Appends a valid Radar-issued marker as a Pi custom session entry. */
+export function appendRadarLaunchMarker(
+	appendEntry: AppendSessionEntry,
+	marker: RadarLaunchMarker,
+): void {
+	const validated = decodeRadarLaunchMarker(marker);
+	if (!validated) throw new Error("invalid Radar launch identity marker");
+	appendEntry(RADAR_LAUNCH_MARKER_TYPE, validated);
+}
+
+/**
+ * Reads the newest marker on Pi's current branch. A malformed newest marker is
+ * returned as unresolved rather than silently falling back to an older launch.
+ */
+export function latestRadarLaunchMarker(
+	branch: readonly CustomSessionEntry[],
+): { status: "absent" } | { status: "valid"; marker: RadarLaunchMarker } | { status: "invalid" } {
+	let latest: CustomSessionEntry | undefined;
+	for (const entry of branch) {
+		if (entry.type === "custom" && entry.customType === RADAR_LAUNCH_MARKER_TYPE) {
+			latest = entry;
+		}
+	}
+	if (!latest) return { status: "absent" };
+	const marker = decodeRadarLaunchMarker(latest.data);
+	return marker ? { status: "valid", marker } : { status: "invalid" };
+}
+
+/**
+ * Persist this daemon-injected process identity into the active Pi session branch.
+ * No marker is written when any variable is absent or malformed. Repeated session
+ * starts in the same generation do not append duplicate entries.
+ */
+export function radarLaunchMarkerFromEnvironment(
+	env: Record<string, string | undefined> = process.env,
+): RadarLaunchMarker | undefined {
+	const rawGeneration = env[RADAR_MANAGED_GENERATION_ENV];
+	if (
+		env[RADAR_MANAGED_SUBJECT_ENV] === undefined ||
+		env[RADAR_MANAGED_LAUNCH_ENV] === undefined ||
+		rawGeneration === undefined ||
+		!/^[1-9][0-9]*$/.test(rawGeneration)
+	) {
+		return undefined;
+	}
+	return decodeRadarLaunchMarker({
+		version: RADAR_LAUNCH_MARKER_VERSION,
+		subject_id: env[RADAR_MANAGED_SUBJECT_ENV],
+		launch_id: env[RADAR_MANAGED_LAUNCH_ENV],
+		execution_generation: Number(rawGeneration),
+	});
+}
+
+export function activeRadarLaunchMarker(
+	host: PiSessionMarkerHost,
+): ReturnType<typeof latestRadarLaunchMarker> {
+	if (!host.sessionManager) return { status: "absent" };
+	return latestRadarLaunchMarker(host.sessionManager.getBranch());
+}
+
+export function persistRadarLaunchMarker(
+	host: PiSessionMarkerHost,
+	env: Record<string, string | undefined> = process.env,
+): "absent" | "unsupported" | "unchanged" | "written" {
+	const marker = radarLaunchMarkerFromEnvironment(env);
+	if (!marker) return "absent";
+	if (!host.appendEntry || !host.sessionManager) return "unsupported";
+	const current = latestRadarLaunchMarker(host.sessionManager.getBranch());
+	if (current.status === "valid" && sameMarker(current.marker, marker)) return "unchanged";
+	appendRadarLaunchMarker(host.appendEntry, marker);
+	return "written";
+}
+
+function sameMarker(a: RadarLaunchMarker, b: RadarLaunchMarker): boolean {
+	return (
+		a.version === b.version &&
+		a.subject_id === b.subject_id &&
+		a.launch_id === b.launch_id &&
+		a.execution_generation === b.execution_generation
+	);
+}

package/index.ts

@@ -4,3 +4,4 @@ export * as inspection from "./extension/radar-inspection.ts";
 export * as launch from "./extension/radar-launch.ts";
 export * as location from "./extension/radar-location.ts";
 export * as publication from "./extension/radar-publication.ts";
+export * as runtime from "./extension/radar-runtime.ts";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-radar",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "description": "Radar daemon client, publication, execution, location, launch and inspection surface for Pi extensions.",
   "license": "Apache-2.0",
@@ -13,6 +13,9 @@
     "directory": "pi-radar"
   },
   "types": "./index.ts",
+  "pi": {
+    "extensions": ["./extension/baseline.ts"]
+  },
   "exports": {
     ".": {
       "types": "./index.ts",
@@ -30,6 +33,14 @@
       "types": "./extension/radar-publication.ts",
       "import": "./dist/extension/radar-publication.js"
     },
+    "./runtime": {
+      "types": "./extension/radar-runtime.ts",
+      "import": "./dist/extension/radar-runtime.js"
+    },
+    "./baseline": {
+      "types": "./extension/baseline.ts",
+      "import": "./dist/extension/baseline.js"
+    },
     "./launch": {
       "types": "./extension/radar-launch.ts",
       "import": "./dist/extension/radar-launch.js"
@@ -60,13 +71,16 @@
     "extension/radar-inspection.ts",
     "extension/radar-launch.ts",
     "extension/radar-location.ts",
-    "extension/radar-publication.ts"
+    "extension/radar-publication.ts",
+    "extension/radar-session-marker.ts",
+    "extension/radar-runtime.ts",
+    "extension/baseline.ts"
   ],
   "scripts": {
-    "build": "esbuild index.ts extension/generated-contracts.ts extension/radar-client.ts extension/radar-execution.ts extension/radar-inspection.ts extension/radar-launch.ts extension/radar-location.ts extension/radar-publication.ts --outbase=. --outdir=dist --bundle --platform=node --format=esm --target=node22",
+    "build": "esbuild index.ts extension/generated-contracts.ts extension/radar-client.ts extension/radar-execution.ts extension/radar-inspection.ts extension/radar-launch.ts extension/radar-location.ts extension/radar-publication.ts extension/radar-session-marker.ts extension/radar-runtime.ts extension/baseline.ts --outbase=. --outdir=dist --bundle --platform=node --format=esm --target=node22",
     "generate:contracts": "node tools/generate-contracts.mjs",
     "check:contracts": "node tools/generate-contracts.mjs --check",
-    "typecheck:contracts": "tsc --noEmit --strict --skipLibCheck --target ES2022 --module NodeNext --moduleResolution NodeNext --allowImportingTsExtensions --types node extension/generated-contracts.ts extension/generated-contracts.typecheck.ts",
+    "typecheck:contracts": "tsc --noEmit --strict --skipLibCheck --target ES2022 --module NodeNext --moduleResolution NodeNext --allowImportingTsExtensions --types node index.ts extension/baseline.ts extension/generated-contracts.ts extension/generated-contracts.typecheck.ts extension/radar-client.ts extension/radar-execution.ts extension/radar-publication.ts extension/radar-session-marker.ts extension/radar-session-marker.test.ts extension/radar-runtime.ts extension/radar-runtime.test.ts",
     "prepack": "npm run build",
     "test": "npm run check:contracts && npm run typecheck:contracts && node --experimental-strip-types --test extension/*.test.ts"
   },

package/schema/public/v1/launch-identity-marker.deserialize.schema.json

@@ -0,0 +1,32 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "additionalProperties": false,
+  "description": "A non-secret Pi-session breadcrumb issued by Radar. This is correlation\nevidence only and cannot establish lifecycle authority.",
+  "properties": {
+    "execution_generation": {
+      "format": "uint32",
+      "maximum": 4294967295,
+      "minimum": 1,
+      "type": "integer"
+    },
+    "launch_id": {
+      "type": "string"
+    },
+    "subject_id": {
+      "type": "string"
+    },
+    "version": {
+      "format": "uint32",
+      "minimum": 0,
+      "type": "integer"
+    }
+  },
+  "required": [
+    "version",
+    "subject_id",
+    "launch_id",
+    "execution_generation"
+  ],
+  "title": "launch-identity-marker-deserialize",
+  "type": "object"
+}

package/schema/public/v1/launch-identity-marker.serialize.schema.json

@@ -0,0 +1,32 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "additionalProperties": false,
+  "description": "A non-secret Pi-session breadcrumb issued by Radar. This is correlation\nevidence only and cannot establish lifecycle authority.",
+  "properties": {
+    "execution_generation": {
+      "format": "uint32",
+      "maximum": 4294967295,
+      "minimum": 1,
+      "type": "integer"
+    },
+    "launch_id": {
+      "type": "string"
+    },
+    "subject_id": {
+      "type": "string"
+    },
+    "version": {
+      "format": "uint32",
+      "minimum": 0,
+      "type": "integer"
+    }
+  },
+  "required": [
+    "version",
+    "subject_id",
+    "launch_id",
+    "execution_generation"
+  ],
+  "title": "launch-identity-marker-serialize",
+  "type": "object"
+}

package/schema/public/v1/managed-launch-metadata.deserialize.schema.json

@@ -0,0 +1,39 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "additionalProperties": false,
+  "description": "Managed owner/parent metadata accepted with a spawn intent. Domain validation\nand parent-binding checks remain in the daemon handler.",
+  "properties": {
+    "label": {
+      "type": [
+        "string",
+        "null"
+      ]
+    },
+    "owner": {
+      "type": [
+        "string",
+        "null"
+      ]
+    },
+    "parent_subject_id": {
+      "type": [
+        "string",
+        "null"
+      ]
+    },
+    "role": {
+      "type": [
+        "string",
+        "null"
+      ]
+    },
+    "run": {
+      "type": [
+        "string",
+        "null"
+      ]
+    }
+  },
+  "title": "managed-launch-metadata-deserialize",
+  "type": "object"
+}

package/schema/public/v1/managed-launch-metadata.serialize.schema.json

@@ -0,0 +1,39 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "additionalProperties": false,
+  "description": "Managed owner/parent metadata accepted with a spawn intent. Domain validation\nand parent-binding checks remain in the daemon handler.",
+  "properties": {
+    "label": {
+      "type": [
+        "string",
+        "null"
+      ]
+    },
+    "owner": {
+      "type": [
+        "string",
+        "null"
+      ]
+    },
+    "parent_subject_id": {
+      "type": [
+        "string",
+        "null"
+      ]
+    },
+    "role": {
+      "type": [
+        "string",
+        "null"
+      ]
+    },
+    "run": {
+      "type": [
+        "string",
+        "null"
+      ]
+    }
+  },
+  "title": "managed-launch-metadata-serialize",
+  "type": "object"
+}