pi-radar 0.1.0 → 0.3.0

package/dist/extension/radar-runtime.js

@@ -0,0 +1,42 @@
+// extension/radar-runtime.ts
+var RADAR_RUNTIME_REQUEST = "pi-radar/runtime-request";
+var RADAR_RUNTIME_VERSION = 2;
+function lazyRadarRuntime(start) {
+  let pending;
+  return {
+    version: RADAR_RUNTIME_VERSION,
+    start: () => pending ??= Promise.resolve().then(start)
+  };
+}
+function provideRadarRuntime(events, handle) {
+  return events.on(RADAR_RUNTIME_REQUEST, (value) => {
+    if (!isRuntimeRequest(value)) return;
+    value.provide(handle);
+  });
+}
+function requestRadarRuntime(events) {
+  const handles = [];
+  events.emit(RADAR_RUNTIME_REQUEST, {
+    version: RADAR_RUNTIME_VERSION,
+    provide: (candidate) => {
+      if (isRadarRuntimeHandle(candidate)) handles.push(candidate);
+    }
+  });
+  if (handles.length === 1) return { ok: true, handle: handles[0] };
+  return { ok: false, reason: handles.length === 0 ? "missing" : "duplicate" };
+}
+function isRuntimeRequest(value) {
+  return typeof value === "object" && value !== null && value.version === RADAR_RUNTIME_VERSION && typeof value.provide === "function";
+}
+function isRadarRuntimeHandle(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const handle = value;
+  return handle.version === RADAR_RUNTIME_VERSION && typeof handle.start === "function";
+}
+export {
+  RADAR_RUNTIME_REQUEST,
+  RADAR_RUNTIME_VERSION,
+  lazyRadarRuntime,
+  provideRadarRuntime,
+  requestRadarRuntime
+};

package/dist/extension/radar-session-marker.js

@@ -0,0 +1,82 @@
+// extension/radar-session-marker.ts
+var RADAR_LAUNCH_MARKER_TYPE = "pi-radar.launch-identity";
+var RADAR_LAUNCH_MARKER_VERSION = 1;
+var RADAR_MAX_EXECUTION_GENERATION = 4294967295;
+var RADAR_MANAGED_SUBJECT_ENV = "PI_RADAR_MANAGED_SUBJECT_ID";
+var RADAR_MANAGED_LAUNCH_ENV = "PI_RADAR_MANAGED_LAUNCH_ID";
+var RADAR_MANAGED_GENERATION_ENV = "PI_RADAR_MANAGED_EXECUTION_GENERATION";
+var 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;
+function decodeRadarLaunchMarker(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+  const record = value;
+  if (Object.keys(record).sort().join(",") !== "execution_generation,launch_id,subject_id,version") {
+    return void 0;
+  }
+  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 < 1 || record.execution_generation > RADAR_MAX_EXECUTION_GENERATION) {
+    return void 0;
+  }
+  return {
+    version: RADAR_LAUNCH_MARKER_VERSION,
+    subject_id: record.subject_id,
+    launch_id: record.launch_id,
+    execution_generation: record.execution_generation
+  };
+}
+function appendRadarLaunchMarker(appendEntry, marker) {
+  const validated = decodeRadarLaunchMarker(marker);
+  if (!validated) throw new Error("invalid Radar launch identity marker");
+  appendEntry(RADAR_LAUNCH_MARKER_TYPE, validated);
+}
+function latestRadarLaunchMarker(branch) {
+  let latest;
+  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" };
+}
+function radarLaunchMarkerFromEnvironment(env = process.env) {
+  const rawGeneration = env[RADAR_MANAGED_GENERATION_ENV];
+  if (env[RADAR_MANAGED_SUBJECT_ENV] === void 0 || env[RADAR_MANAGED_LAUNCH_ENV] === void 0 || rawGeneration === void 0 || !/^[1-9][0-9]*$/.test(rawGeneration)) {
+    return void 0;
+  }
+  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)
+  });
+}
+function activeRadarLaunchMarker(host) {
+  if (!host.sessionManager) return { status: "absent" };
+  return latestRadarLaunchMarker(host.sessionManager.getBranch());
+}
+function persistRadarLaunchMarker(host, env = process.env) {
+  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, b) {
+  return a.version === b.version && a.subject_id === b.subject_id && a.launch_id === b.launch_id && a.execution_generation === b.execution_generation;
+}
+export {
+  RADAR_LAUNCH_MARKER_TYPE,
+  RADAR_LAUNCH_MARKER_VERSION,
+  RADAR_MANAGED_GENERATION_ENV,
+  RADAR_MANAGED_LAUNCH_ENV,
+  RADAR_MANAGED_SUBJECT_ENV,
+  RADAR_MAX_EXECUTION_GENERATION,
+  activeRadarLaunchMarker,
+  appendRadarLaunchMarker,
+  decodeRadarLaunchMarker,
+  latestRadarLaunchMarker,
+  persistRadarLaunchMarker,
+  radarLaunchMarkerFromEnvironment
+};