@remit/web-client 0.0.114 → 0.0.115

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/web-client",
-  "version": "0.0.114",
+  "version": "0.0.115",
   "type": "module",
   "description": "Remit web client, published as composable primitives — the app shell, auth shells, and runtime config. A distributor imports what it composes and bundles it.",
   "exports": {

package/src/hooks/use-system-update.test.ts

@@ -236,6 +236,28 @@ describe("SelfUpdateOverlay — the blocking screen", () => {
 		assert.match(dom.html(), /has not answered since the restart/);
 		assert.match(dom.html(), /remit logs/);
 	});
+
+	test("a poll that never answers gives up at the budget too", async () => {
+		saveHeldRun({
+			runId: "upd_1",
+			attemptedVersion: "0.9.4",
+			previousVersion: "0.9.3",
+			startedAt: Date.now() - 60 * 60_000,
+		});
+		http = mockFetch(() => new Promise(() => {}));
+		harness = createDomHarness();
+		harness.renderApp(
+			createElement(SelfUpdateProvider, null, createElement(SelfUpdateOverlay)),
+		);
+		await harness.flush();
+		await harness.wait(1);
+		await harness.flush();
+
+		assert.doesNotMatch(harness.html(), /Installing Remit 0\.9\.4/);
+		assert.match(harness.html(), /has not answered since the restart/);
+		assert.match(harness.html(), /remit logs/);
+		assert.equal(loadHeldRun(), null);
+	});
 });
 
 describe("useSystemUpdate — actions", () => {

package/src/lib/self-update-state.test.ts

@@ -470,6 +470,30 @@ describe("deriveUpdateSurface — a held run across a restart", () => {
 		assert.equal(result.releaseHeld, true);
 	});
 
+	test("a first poll still in flight keeps applying inside the budget", () => {
+		const result = deriveUpdateSurface(
+			input({ held: held({ startedAt: NOW - 20_000 }) }),
+		);
+		if (
+			result.surface.status !== "ready" ||
+			result.surface.overlay.kind !== "applying"
+		) {
+			assert.fail("expected the applying overlay");
+		}
+		assert.equal(result.surface.overlay.phase, "preparing");
+		assert.equal(result.clearStoredRun, false);
+	});
+
+	test("a poll that never answers gives up at the budget", () => {
+		const result = deriveUpdateSurface(
+			input({ held: held({ startedAt: NOW - BUDGET_MS - 60_000 }) }),
+		);
+		assert.equal(result.surface.status, "ready");
+		if (result.surface.status !== "ready") return;
+		assert.equal(result.surface.overlay.kind, "neverCameBack");
+		assert.equal(result.clearStoredRun, true);
+	});
+
 	test("an early server answer with no run yet keeps applying", () => {
 		const result = deriveUpdateSurface(
 			input({ data: response({ run: null }), held: held() }),

package/src/lib/self-update-state.ts

@@ -9,9 +9,10 @@
  *
  * The design constraints (RFC 037 Interface, issue #135) live here:
  *  - A held run id turns a failed request into `applying`, never `unreachable`.
- *  - Once the apply budget plus a margin has passed with no answer, the same
- *    failure becomes "the server never came back" — a state that never claims
- *    the rollback ran, because from a dead connection the client cannot know.
+ *  - Once the apply budget plus a margin has passed with no answer — a failed
+ *    request or one still in flight — that silence becomes "the server never
+ *    came back", a state that never claims the rollback ran, because from a
+ *    dead connection the client cannot know.
  *  - The check block and the run block are independent: a check that cannot
  *    reach the update source is a failed check, never a failed update.
  */
@@ -325,6 +326,35 @@ function ready(
 	};
 }
 
+/**
+ * The client gave up waiting. The stored token goes so a reload cannot resume
+ * the same dead wait, while the in-memory hold stays: the screen has to sit
+ * still, and its retry has to keep polling, until the server answers for itself.
+ */
+function neverCameBack(held: HeldRun, elapsedSeconds: number): DeriveResult {
+	return {
+		surface: {
+			status: "ready",
+			section: applyingSection(
+				held.runId,
+				held.previousVersion,
+				held.attemptedVersion,
+				"reconnecting",
+				elapsedSeconds,
+			),
+			overlay: {
+				kind: "neverCameBack",
+				attemptedVersion: held.attemptedVersion,
+				previousVersion: held.previousVersion,
+				elapsedSeconds,
+				logsCommand: FALLBACK_LOGS_COMMAND,
+			},
+		},
+		clearStoredRun: true,
+		releaseHeld: false,
+	};
+}
+
 /**
  * A held run resolves to one of: still applying, gave up ("never came back"),
  * recovered but unaccountable, or — returning `null` — resolved terminally on
@@ -360,32 +390,17 @@ function deriveHeld(
 	}
 
 	if (isError) {
-		const section = applyingSection(
-			held.runId,
-			held.previousVersion,
-			held.attemptedVersion,
-			"reconnecting",
-			elapsedSeconds,
-		);
 		if (elapsedSeconds > budgetLimitSeconds()) {
-			return {
-				surface: {
-					status: "ready",
-					section,
-					overlay: {
-						kind: "neverCameBack",
-						attemptedVersion: held.attemptedVersion,
-						previousVersion: held.previousVersion,
-						elapsedSeconds,
-						logsCommand: FALLBACK_LOGS_COMMAND,
-					},
-				},
-				clearStoredRun: true,
-				releaseHeld: false,
-			};
+			return neverCameBack(held, elapsedSeconds);
 		}
 		return ready(
-			section,
+			applyingSection(
+				held.runId,
+				held.previousVersion,
+				held.attemptedVersion,
+				"reconnecting",
+				elapsedSeconds,
+			),
 			{
 				kind: "applying",
 				target: held.attemptedVersion,
@@ -397,9 +412,14 @@ function deriveHeld(
 		);
 	}
 
-	// No answer yet — the resume request is still in flight. Stay applying; only
-	// a real error or a real answer moves off it, never a pending first poll.
+	// No answer yet — the resume request is still in flight. A request that is
+	// pending looks exactly like one that will never settle, so the budget bounds
+	// this wait too: within it the client stays applying, past it it stops
+	// claiming an install is running and says what it cannot account for.
 	if (data === undefined) {
+		if (elapsedSeconds > budgetLimitSeconds()) {
+			return neverCameBack(held, elapsedSeconds);
+		}
 		return ready(
 			applyingSection(
 				held.runId,

package/src/test-support/http.ts

@@ -22,7 +22,8 @@ type Responder = (call: HttpCall) => unknown;
 
 /**
  * Answer every request with `responder`'s return value as JSON. Throwing from
- * the responder, or returning a `Response`, is how a test drives a failure.
+ * the responder, or returning a `Response`, is how a test drives a failure;
+ * returning a promise that never settles is how it drives a request that hangs.
  */
 export const mockFetch = (responder: Responder = () => ({})): HttpMock => {
 	const original = globalThis.fetch;
@@ -43,7 +44,7 @@ export const mockFetch = (responder: Responder = () => ({})): HttpMock => {
 		};
 		calls.push(call);
 
-		const result = responder(call);
+		const result = await responder(call);
 		if (result instanceof Response) return result;
 		return new Response(JSON.stringify(result ?? {}), {
 			status: 200,