pi-radar 0.9.0 → 0.10.0

package/dist/extension/radar-launch.js

@@ -8,11 +8,6 @@ function isUuid(value) {
   return typeof value === "string" && UUID.test(value);
 }
 
-// extension/radar-location.ts
-function radarPaneHandle(qualified) {
-  return qualified.slice(qualified.lastIndexOf(":") + 1);
-}
-
 // extension/radar-launch.ts
 function unknownChild(reason) {
   return { kind: "unknown", diagnostic: trajectory(reason) };
@@ -104,7 +99,7 @@ async function relaunchRefusalForChild(client, agentId) {
   return `the child's registered process is ${verification === "verified" ? "still running" : "not proved gone"}`;
 }
 function refusedLaunch(message) {
-  return { kind: "refused", message };
+  return { kind: "failed", message };
 }
 function unresolvedLaunch(requestId, message) {
   return {
@@ -113,14 +108,6 @@ function unresolvedLaunch(requestId, message) {
     message: `spawn ${requestId} is unresolved (${message})`
   };
 }
-function edgeStanding(edge) {
-  if (edge.created === "refused" || edge.launched === "refused")
-    return "refused";
-  return edge.created === "completed" && edge.launched === "completed" ? "launched" : "unknown";
-}
-function edgeMessage(edge) {
-  return `the daemon's spawn record is created ${edge.created} and launched ${edge.launched}`;
-}
 var PRE_EFFECT_CODES = [
   "absent",
   "unsupported",
@@ -133,14 +120,12 @@ var PRE_EFFECT_CODES = [
   "busy",
   "backend_unavailable"
 ];
-function spawnFailure(result, requestId) {
+function launchFailure(result, requestId) {
   return PRE_EFFECT_CODES.includes(result.code) ? refusedLaunch(result.message) : unresolvedLaunch(requestId, result.message);
 }
 async function launchRadarWorker(options) {
   const { client, launch, signal } = options;
   const pollMs = options.pollMs ?? 250;
-  const deadline = Date.now() + options.timeoutMs;
-  const remaining = () => Math.max(0, deadline - Date.now());
   const parent = await options.publication.subject();
   if (parent === void 0 || !isUuid(parent.registration_id))
     return refusedLaunch(
@@ -171,55 +156,22 @@ async function launchRadarWorker(options) {
     ...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 !== void 0 ? { 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 !== void 0 ? { 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 !== void 0 && 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
+    }
+  };
 }
 async function waitForChild(client, requestId, options) {
   let last = "the daemon has not answered";
@@ -228,37 +180,21 @@ async function waitForChild(client, requestId, options) {
       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 !== void 0)
+        return refusedLaunch(`the daemon withdrew this launch: ${edge.withdrawn.reason}`);
+      if (edge.granted_at === void 0) {
+        await delay(options.pollMs);
+        continue;
+      }
       const pane = edge.location?.pane;
       if (pane === void 0 || pane === "")
         return unresolvedLaunch(
           requestId,
           "the daemon's launch recorded no pane to verify the child against"
         );
-      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`
-        );
-      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 !== void 0 && isUuid(agentId)) {
-        const source = edge.bound?.source;
-        const incarnation = edge.bound?.incarnation;
-        if (source === void 0 || source === "" || incarnation === void 0 || incarnation === "")
-          return unresolvedLaunch(
-            requestId,
-            `the daemon bound the child ${agentId} without recording the process it registered as`
-          );
         const subjectId = edge.bound?.subject_id;
         if (subjectId === void 0 || !isUuid(subjectId))
           return unresolvedLaunch(
@@ -268,26 +204,21 @@ async function waitForChild(client, requestId, options) {
         return {
           kind: "bound",
           subject_id: subjectId,
-          registration_id: agentId,
-          pane_id: pane,
-          source,
-          incarnation
+          pane_id: pane
         };
       }
       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, void 0, {
-      ...options.signal !== void 0 ? { signal: options.signal } : {}
-    });
+    await delay(options.pollMs);
   }
 }
 export {
+  launchFailure,
   launchRadarWorker,
   observeRadarChild,
   readProcessGone,
-  relaunchRefusalForChild
+  relaunchRefusalForChild,
+  waitForChild
 };

package/dist/extension/radar-runtime.js

@@ -1,6 +1,6 @@
 // extension/radar-runtime.ts
 var RADAR_RUNTIME_REQUEST = "pi-radar/runtime-request";
-var RADAR_RUNTIME_VERSION = 3;
+var RADAR_RUNTIME_VERSION = 4;
 function lazyRadarRuntime(start) {
   let pending;
   return {