@cmmd-center/forge 0.13.87 → 0.13.89

package/dist/bin.mjs

@@ -22352,6 +22352,16 @@ const TerminalFontSize = Int$1.check(isGreaterThanOrEqualTo(8)).check(isLessThan
 const FontFamilyPreference = String$1.check(isMaxLength(200));
 const AutoSettleAfterDays = NullOr(Int$1.check(isGreaterThanOrEqualTo(1)).check(isLessThanOrEqualTo(90)));
 const GlassOpacity = Int$1.check(isGreaterThanOrEqualTo(40)).check(isLessThanOrEqualTo(100));
+/**
+* Interface contrast, in percent of the shipped look. 100 disables mixing;
+* above it the `--contrast-*` axis in `apps/web/src/index.css` raises text
+* and border contrast from the semantic roles, below it softens them.
+* Upstream's axis and bounds, adopted by the token union.
+*/
+const AppearanceContrast = Int$1.check(isBetween({
+	minimum: 50,
+	maximum: 200
+}));
 const DEFAULT_CLIENT_SETTINGS = decodeSync(Struct({
 	theme: ThemePreference.pipe(withDecodingDefault(succeed("system"))),
 	themeId: ThemeId,
@@ -22367,6 +22377,7 @@ const DEFAULT_CLIENT_SETTINGS = decodeSync(Struct({
 	fontSmoothing: Boolean$1.pipe(withDecodingDefault(succeed(true))),
 	sidebarAutoSettleAfterDays: AutoSettleAfterDays.pipe(withDecodingDefault(succeed(3))),
 	glassOpacity: GlassOpacity.pipe(withDecodingDefault(succeed(80))),
+	appearanceContrast: AppearanceContrast.pipe(withDecodingDefault(succeed(100))),
 	confirmThreadArchive: Boolean$1.pipe(withDecodingDefault(succeed(true))),
 	confirmThreadDelete: Boolean$1.pipe(withDecodingDefault(succeed(true))),
 	showInteractionModeToggle: Boolean$1.pipe(withDecodingDefault(succeed(false))),
@@ -65994,7 +66005,7 @@ function normalizeNumberish(value) {
 }
 //#endregion
 //#region package.json
-var version$1 = "0.13.87";
+var version$1 = "0.13.89";
 //#endregion
 //#region src/sentry.ts
 const SERVER_APP_NAME = "forge-server";
@@ -241337,6 +241348,22 @@ function resolveSpriteTaskHoldConfig(env = process.env) {
 function spriteTaskHoldName(namePrefix, turnId) {
 	return `${namePrefix}${turnId}`;
 }
+/**
+* Thrown by the production transport when the guest API answers a non-2xx
+* status. Carries the status so a caller can tell a 409 (already held, and
+* generally benign) apart from a real transport failure.
+*/
+var SpriteTaskHoldTransportError = class extends Error {
+	status;
+	constructor(status) {
+		super(`sprite task API responded ${status}`);
+		this.name = "SpriteTaskHoldTransportError";
+		this.status = status;
+	}
+};
+function transportStatus(cause) {
+	return cause instanceof SpriteTaskHoldTransportError ? cause.status : void 0;
+}
 const noTimer = () => {};
 /**
 * Resolve with `promise`, but stop waiting after `timeoutMs`. Rejections pass
@@ -241370,12 +241397,25 @@ var SpriteTaskHoldManager = class {
 	#transport;
 	#timer;
 	#onError;
+	#onEvent;
 	#holds = /* @__PURE__ */ new Map();
 	constructor(options) {
 		this.#config = options.config;
 		this.#transport = options.transport;
 		this.#timer = options.timer ?? DEFAULT_TIMER;
 		this.#onError = options.onError ?? (() => {});
+		this.#onEvent = options.onEvent ?? (() => {});
+	}
+	/** Compose and report one acquire/refresh/release outcome, if a caller wants to log it. */
+	#emitEvent(action, holdKey, hold, outcome, status) {
+		this.#onEvent({
+			action,
+			holdKey,
+			holdName: hold.name,
+			threadId: hold.threadId,
+			outcome,
+			...status !== void 0 ? { status } : {}
+		});
 	}
 	/** Turn ids that currently hold the sprite awake. Test/diagnostic surface. */
 	activeTurnIds() {
@@ -241384,10 +241424,19 @@ var SpriteTaskHoldManager = class {
 	/**
 	* `maxRefreshes` bounds a hold that has no terminal event of its own, such as a launch
 	* whose turn may never start. When the budget is spent the hold releases itself.
+	*
+	* Resolves to whether this hold has ever landed a PUT, never throwing (a
+	* hold problem must not fail a turn). A caller handing off from a
+	* predecessor hold (forge#3589) must not release it on anything less than
+	* "succeeded": a failed initial PUT still installs the refresher below and
+	* keeps retrying every `SPRITE_TASK_HOLD_REFRESH_MS`, so the predecessor is
+	* the only thing covering the sprite until one of those retries lands. A
+	* duplicate call against a live, unreleased hold reports that hold's own
+	* confirmed state rather than a blanket "succeeded", for the same reason.
 	*/
 	async acquire(turnId, threadId = null, options = {}) {
-		const existing = this.#holds.get(turnId);
-		if (existing !== void 0 && !existing.released) return;
+		const existing = this.#liveHold(turnId);
+		if (existing !== void 0) return existing.confirmed ? "succeeded" : "failed";
 		let refreshesLeft = options.maxRefreshes ?? Number.POSITIVE_INFINITY;
 		const name = spriteTaskHoldName(this.#config.namePrefix, turnId);
 		const hold = {
@@ -241399,24 +241448,54 @@ var SpriteTaskHoldManager = class {
 			phase: "idle",
 			releaseAttempt: null,
 			deletion: null,
-			uncertainPut: false
+			uncertainPut: false,
+			confirmed: false
 		};
 		this.#holds.set(turnId, hold);
 		const put = this.#transport.put(name, 300);
 		const tracked = put.then(() => "succeeded", () => "failed");
 		hold.inFlight.add(tracked);
+		let outcome = "succeeded";
 		try {
 			await put;
 			hold.uncertainPut = false;
+			hold.confirmed = true;
+			this.#emitEvent("acquire", turnId, hold, "success");
 		} catch (cause) {
+			outcome = "failed";
 			hold.uncertainPut = true;
 			hold.inFlight.delete(tracked);
 			this.#onError(`failed to acquire sprite task hold for turn ${turnId}`, cause);
-			if (hold.released || this.#holds.get(turnId) !== hold) return;
+			this.#emitEvent("acquire", turnId, hold, "failure", transportStatus(cause));
+			if (this.#isStale(turnId, hold)) return outcome;
 		}
 		hold.inFlight.delete(tracked);
-		if (hold.released || this.#holds.get(turnId) !== hold) return;
-		hold.refresher = this.#timer.setInterval(() => {
+		if (this.#isStale(turnId, hold)) return outcome;
+		hold.refresher = this.#installRefresher(turnId, hold, name, refreshesLeft);
+		return outcome;
+	}
+	/** The hold registered for `turnId`, if it is still live: not mid-release or concluded. */
+	#liveHold(turnId) {
+		const existing = this.#holds.get(turnId);
+		return existing !== void 0 && !existing.released ? existing : void 0;
+	}
+	/**
+	* Whether `hold` has been superseded since the caller last checked: either
+	* released, or no longer the map's current entry for `turnId` (a fresh
+	* acquire replaced it). Both `acquire`'s post-await fences use this so
+	* neither has to repeat the compound condition inline.
+	*/
+	#isStale(turnId, hold) {
+		return hold.released || this.#holds.get(turnId) !== hold;
+	}
+	/**
+	* Install a hold's refresh interval. Extracted out of `acquire` so that
+	* method's own branching stays flat; the ordering and identity-fence rules
+	* around it are unchanged, and this closure owns only the refresh tick.
+	*/
+	#installRefresher(turnId, hold, name, initialBudget) {
+		let refreshesLeft = initialBudget;
+		return this.#timer.setInterval(() => {
 			if (hold.inFlight.size > 0) return;
 			if (refreshesLeft <= 0) {
 				if (this.#holds.get(turnId) === hold) this.release(turnId);
@@ -241425,10 +241504,13 @@ var SpriteTaskHoldManager = class {
 			refreshesLeft -= 1;
 			const refresh = this.#transport.put(name, 300).then(() => {
 				hold.uncertainPut = false;
+				hold.confirmed = true;
+				this.#emitEvent("refresh", turnId, hold, "success");
 				return "succeeded";
 			}, (cause) => {
 				hold.uncertainPut = true;
 				this.#onError(`failed to refresh sprite task hold for turn ${turnId}`, cause);
+				this.#emitEvent("refresh", turnId, hold, "failure", transportStatus(cause));
 				return "failed";
 			});
 			hold.inFlight.add(refresh);
@@ -241472,6 +241554,7 @@ var SpriteTaskHoldManager = class {
 		hold.phase = "joining";
 		const attempt = (async () => {
 			const outcome = await this.#concludeRelease(hold, turnId, options);
+			this.#emitEvent("release", turnId, hold, outcome);
 			if (outcome === "unreleased") {
 				hold.phase = "idle";
 				this.#removeIfCurrent(turnId, hold);
@@ -241655,7 +241738,7 @@ function makeSpriteTaskHoldTransport(config, fetchImpl = fetch) {
 				signal: controller.signal,
 				unix: config.socketPath
 			});
-			if (!response.ok) throw new Error(`sprite task API responded ${response.status}`);
+			if (!response.ok) throw new SpriteTaskHoldTransportError(response.status);
 		} finally {
 			clearTimeout(deadline);
 		}
@@ -241691,13 +241774,14 @@ function makeSpriteTaskHoldTransport(config, fetchImpl = fetch) {
 * Build a manager for this process, or null when the runtime is not a sprite.
 * Callers treat null as "this feature does not apply here".
 */
-function makeSpriteTaskHoldManager(env = process.env, onError) {
+function makeSpriteTaskHoldManager(env = process.env, onError, onEvent) {
 	const config = resolveSpriteTaskHoldConfig(env);
 	if (config === null) return null;
 	return new SpriteTaskHoldManager({
 		config,
 		transport: makeSpriteTaskHoldTransport(config),
-		...onError ? { onError } : {}
+		...onError ? { onError } : {},
+		...onEvent ? { onEvent } : {}
 	});
 }
 //#endregion
@@ -286277,7 +286361,7 @@ const AgentBrowserManagerLive = effect(BrowserManager, gen(function* () {
 	const displayPeers = createWebRtcDisplaySessionManager({
 		mediaSourceFactory: displayCaptureRuntime.mediaSourceFactory,
 		taskHold: displayTaskHoldManager ? {
-			acquire: (holdId) => displayTaskHoldManager.acquire(holdId),
+			acquire: (holdId) => displayTaskHoldManager.acquire(holdId).then(() => {}),
 			release: (holdId) => displayTaskHoldManager.release(holdId).then(() => {})
 		} : void 0
 	});
@@ -294615,6 +294699,15 @@ const SpriteTaskHoldReactorLive = effect(SpriteTaskHoldReactor, gen(function* ()
 	const providerService = yield* ProviderService;
 	const manager = makeSpriteTaskHoldManager(process.env, (message, cause) => {
 		runFork(logWarning$1(message, { cause: cause instanceof Error ? cause.message : cause }));
+	}, (event) => {
+		runFork(logInfo("sprite task hold", {
+			action: event.action,
+			holdKey: event.holdKey,
+			holdName: event.holdName,
+			threadId: event.threadId,
+			outcome: event.outcome,
+			...event.status !== void 0 ? { status: event.status } : {}
+		}));
 	});
 	/**
 	* Run a manager call, or nothing on runtimes that are not sprites. One
@@ -294630,27 +294723,58 @@ const SpriteTaskHoldReactorLive = effect(SpriteTaskHoldReactor, gen(function* ()
 		deleteTimeoutMs: SPRITE_TASK_HOLD_RELEASE_DELETE_TIMEOUT_MS
 	})));
 	const launchCallers = /* @__PURE__ */ new Map();
+	const launchGeneration = /* @__PURE__ */ new Map();
+	const turnLaunchGeneration = /* @__PURE__ */ new Map();
+	/**
+	* Belt-and-braces cleanup for a turn reaching a terminal state
+	* (turn.completed or turn.aborted): a launch hold whose hand-off never
+	* confirmed (the turn hold's PUT kept failing) is still up, refreshing on
+	* its own budget, and the turn ending either way means the launch phase is
+	* over. `manager.release(String(turnId))` above can itself wait on the
+	* guest API, so by the time this runs the NEXT stage's own dispatch may
+	* already have acquired a fresh launch hold for the same thread; only
+	* release it here when no such newer launch has started since this turn's
+	* own turn.started was processed (CodeRabbit review, forge#3592). A no-op
+	* when this turn's own generation is stale, or when the hold was already
+	* released.
+	*/
+	const releaseLingeringLaunchHold = async (turnId, threadId) => {
+		const capturedGeneration = turnLaunchGeneration.get(turnId);
+		turnLaunchGeneration.delete(turnId);
+		if (manager === null || capturedGeneration === void 0) return;
+		if (launchGeneration.get(threadId) !== capturedGeneration) return;
+		await manager.release(launchHoldId(threadId));
+	};
 	const start = fn$1("start")(function* () {
 		if (manager === null) return;
 		yield* forkScoped(runForEach(providerService.streamEvents, (event) => {
 			if (event.type === "turn.started") {
 				const turnId = event.turnId;
 				if (turnId === void 0) return void_$1;
+				const threadId = String(event.threadId);
+				const generation = launchGeneration.get(threadId) ?? 0;
 				return promise(async () => {
-					await manager.acquire(String(turnId), String(event.threadId));
-					launchCallers.delete(String(event.threadId));
-					await manager.release(launchHoldId(String(event.threadId)));
+					const outcome = await manager.acquire(String(turnId), threadId);
+					launchCallers.delete(threadId);
+					turnLaunchGeneration.set(String(turnId), generation);
+					if (outcome === "succeeded") await manager.release(launchHoldId(threadId));
 				});
 			}
 			if (event.type === "turn.completed") {
 				const turnId = event.turnId;
 				if (turnId === void 0) return void_$1;
-				return promise(() => manager.release(String(turnId)).then(() => {}));
+				return promise(async () => {
+					await manager.release(String(turnId));
+					await releaseLingeringLaunchHold(String(turnId), String(event.threadId));
+				});
 			}
 			if (event.type === "turn.aborted") {
 				const turnId = event.turnId;
 				if (turnId === void 0) return void_$1;
-				return promise(() => manager.release(String(turnId)).then(() => {}));
+				return promise(async () => {
+					await manager.release(String(turnId));
+					await releaseLingeringLaunchHold(String(turnId), String(event.threadId));
+				});
 			}
 			if (event.type === "session.exited") {
 				launchCallers.delete(String(event.threadId));
@@ -294662,7 +294786,9 @@ const SpriteTaskHoldReactorLive = effect(SpriteTaskHoldReactor, gen(function* ()
 	/** Takes the launch hold for one more caller. The budget bounds a launch that never starts a turn. */
 	const holdLaunch = (threadId) => promise(async () => {
 		if (manager === null) return;
-		launchCallers.set(threadId, (launchCallers.get(threadId) ?? 0) + 1);
+		const callers = launchCallers.get(threadId) ?? 0;
+		launchCallers.set(threadId, callers + 1);
+		if (callers === 0) launchGeneration.set(threadId, (launchGeneration.get(threadId) ?? 0) + 1);
 		await manager.acquire(launchHoldId(threadId), threadId, { maxRefreshes: LAUNCH_HOLD_MAX_REFRESHES });
 	});
 	/** Lets one caller go. The hold itself is released when the last caller has let go. */
@@ -298802,7 +298928,7 @@ function resolveBuildCommitFromEnv(env) {
 * environment descriptor down instead of reporting an honest "unknown".
 */
 function readBakedBuildCommit() {
-	return "14fc66b40c2ee6a6c8a1574d5c8d9f58e2da093c";
+	return "394b2a7cd449282f2845ec5fa3bd9093f20b8bb8";
 }
 async function resolveServerBuildCommit(input) {
 	if (isFullCommitSha(input.baked)) return input.baked;
@@ -316156,6 +316282,7 @@ const PipelineRunCoordinatorLive = effect(PipelineRunCoordinator, gen(function*
 	const policy = yield* PipelineStagePolicy;
 	const secretStore = yield* ServerSecretStore;
 	const orchestration = yield* OrchestrationEngineService;
+	const spriteTaskHoldReactor = yield* serviceOption(SpriteTaskHoldReactor);
 	const projectionSnapshotQuery = yield* ProjectionSnapshotQuery;
 	const projectionTurns = yield* ProjectionTurnRepository;
 	const changeInspector = yield* PipelineChangeInspector;
@@ -316883,6 +317010,23 @@ const PipelineRunCoordinatorLive = effect(PipelineRunCoordinator, gen(function*
 		});
 		yield* drainReports();
 	});
+	/**
+	* Holds the sprite awake around a freshly dispatched thread.turn.start, the
+	* same way bootstrapLaunch.ts's withLaunchHold does for a turn started from
+	* the Forge web composer or a bootstrap launch (forge#3589). A turn kicked
+	* from a CMMD card reaches the engine through dispatchStage /
+	* recoverMissingProviderStart below, never through that HTTP dispatch
+	* route, so nothing else covers the window between this dispatch and the
+	* provider's own turn.started.
+	*
+	* Releases only on error: a successful dispatch hands the hold off to the
+	* turn's own, in SpriteTaskHoldReactor's turn.started handler.
+	*/
+	const withPipelineLaunchHold = (threadId, dispatch) => {
+		if (isNone(spriteTaskHoldReactor)) return dispatch;
+		const reactor = spriteTaskHoldReactor.value;
+		return uninterruptible(reactor.holdLaunch(threadId)).pipe(andThen(yieldNow), andThen(dispatch), onError$1(() => reactor.releaseLaunch(threadId)));
+	};
 	const dispatchStage = (binding, snapshot, authority) => gen(function* () {
 		const thread = (yield* orchestration.getReadModel()).threads.find((candidate) => candidate.id === ThreadId.make(binding.threadId) && candidate.deletedAt === null);
 		if (thread === void 0) {
@@ -316958,7 +317102,7 @@ const PipelineRunCoordinatorLive = effect(PipelineRunCoordinator, gen(function*
 			messageId: `${commandId}:message`,
 			createdAt: startedAt
 		});
-		yield* orchestration.dispatch(command).pipe(tapError(() => store.resetDispatch(binding.runId, commandId)));
+		yield* withPipelineLaunchHold(binding.threadId, orchestration.dispatch(command)).pipe(tapError(() => store.resetDispatch(binding.runId, commandId)));
 		yield* store.markDispatched(binding.runId, commandId);
 	});
 	const resumeRun = (runId) => gen(function* () {
@@ -317598,7 +317742,7 @@ const PipelineRunCoordinatorLive = effect(PipelineRunCoordinator, gen(function*
 			});
 			if (workerCoordination.kind !== "single" && workerCoordination.kind !== "ready") return;
 			const commandId = `${originalCommandId}:provider-start-recovery`;
-			yield* orchestration.dispatch(buildStageTurnCommand({
+			yield* withPipelineLaunchHold(input.binding.threadId, orchestration.dispatch(buildStageTurnCommand({
 				binding: input.binding,
 				attempt: input.binding.attempt,
 				snapshot: input.snapshot,
@@ -317609,7 +317753,7 @@ const PipelineRunCoordinatorLive = effect(PipelineRunCoordinator, gen(function*
 				commandId,
 				messageId: `${commandId}:message`,
 				createdAt: (/* @__PURE__ */ new Date()).toISOString()
-			}));
+			})));
 		});
 	}
 	function reconcileActiveThread(input) {