overmux 0.0.8 → 0.0.9

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # overmux
 
+## 0.0.9
+
+### Patch Changes
+
+- [#22](https://github.com/richardgill/overmux/pull/22) [`26b2b78`](https://github.com/richardgill/overmux/commit/26b2b789932813bea670cfcc35d9c5fdbbfac193) Thanks [@richardgill](https://github.com/richardgill)! - Allow resource subscriptions to set up asynchronously, safely release cleanup returned after cancellation, and refresh subscribers after setup completes.
+
+- [#17](https://github.com/richardgill/overmux/pull/17) [`405ec4c`](https://github.com/richardgill/overmux/commit/405ec4c250415a168766b7192dbb7c9c2e991ea9) Thanks [@richardgill](https://github.com/richardgill)! - Replace legacy Git source-control resources with independent read-only status and selected-file diff resources. Remove the Git React UI, including its views, navigation commands, stylesheet, and browser exports. Pi now owns the patch renderer it uses directly.
+
+  Preserve resource invalidations received during an active client read so subscribed views refresh after that read settles.
+
 ## 0.0.8
 
 ### Patch Changes

package/dist/bin.js

@@ -2732,6 +2732,33 @@ var getInvalidatedResourceIds = (graph, resourceId) => {
 };
 //#endregion
 //#region src/internal/server/runtime/runtime-resources.ts
+var createSubscriptionLifetime = ({ entry, invalidationListeners, lifecycle, signal }) => {
+	const controller = new AbortController();
+	const subscriptionSignal = AbortSignal.any([lifecycle.requestSignal(signal), controller.signal]);
+	subscriptionSignal.throwIfAborted();
+	const registeredEntry = {
+		...entry,
+		listener: () => {
+			if (!subscriptionSignal.aborted) entry.listener();
+		}
+	};
+	const disposers = [];
+	const release = lifecycle.track(async () => {
+		invalidationListeners.delete(registeredEntry);
+		await lifecycle.disposeAll(disposers);
+	}, subscriptionSignal);
+	const dispose = () => {
+		controller.abort(/* @__PURE__ */ new Error("Resource subscription closed"));
+		return release();
+	};
+	invalidationListeners.add(registeredEntry);
+	return {
+		dispose,
+		disposers,
+		refresh: registeredEntry.listener,
+		signal: subscriptionSignal
+	};
+};
 var createRuntimeResources = ({ definitions, instance, lifecycle }) => {
 	const graph = createResourceDependencyGraph(definitions);
 	const invalidationListeners = /* @__PURE__ */ new Set();
@@ -2763,44 +2790,55 @@ var createRuntimeResources = ({ definitions, instance, lifecycle }) => {
 		operationSignal.throwIfAborted();
 		return definition.contract.output.parse(rawOutput);
 	};
-	const activateWatchers = (id, rawInput, signal, activated, disposers) => {
+	const activateSubscriptions = async (id, rawInput, signal, activated, disposers) => {
+		signal.throwIfAborted();
 		if (activated.has(id)) return;
 		activated.add(id);
 		const definition = definitions[id];
 		const input = definition.contract.input.parse(rawInput);
 		if (definition.kind === "subscription") {
-			const dispose = definition.subscribe(input, () => invalidateResource(id, input), context(signal));
+			const dispose = await definition.subscribe(input, () => {
+				if (!signal.aborted) invalidateResource(id, input);
+			}, context(signal));
 			if (typeof dispose !== "function") throw new Error(`Resource ${id} subscribe must return a disposer`);
+			if (signal.aborted) {
+				await dispose();
+				signal.throwIfAborted();
+			}
 			disposers.push(dispose);
 			return;
 		}
-		if (definition.kind === "derived") graph.dependencies.get(id)?.forEach((dependencyId) => {
-			activateWatchers(dependencyId, rawInput, signal, activated, disposers);
-		});
+		if (definition.kind === "derived") for (const dependencyId of graph.dependencies.get(id) ?? []) await activateSubscriptions(dependencyId, rawInput, signal, activated, disposers);
 	};
 	Object.keys(definitions).forEach((name) => {
 		resources.set(name, {
 			read: (input, signal) => read(name, input, signal),
-			subscribe: (rawInput, listener, signal) => {
+			subscribe: async (rawInput, listener, signal) => {
 				lifecycle.requestSignal(signal).throwIfAborted();
-				const entry = {
-					input: definitions[name].contract.input.parse(rawInput),
-					listener,
-					resourceId: name
-				};
-				const watcherDisposers = [];
-				invalidationListeners.add(entry);
+				const subscription = createSubscriptionLifetime({
+					entry: {
+						input: definitions[name].contract.input.parse(rawInput),
+						listener,
+						resourceId: name
+					},
+					invalidationListeners,
+					lifecycle,
+					signal
+				});
 				try {
-					activateWatchers(name, rawInput, signal, /* @__PURE__ */ new Set(), watcherDisposers);
+					await activateSubscriptions(name, rawInput, subscription.signal, /* @__PURE__ */ new Set(), subscription.disposers);
+					subscription.signal.throwIfAborted();
+					subscription.refresh();
+					subscription.signal.throwIfAborted();
+					return subscription.dispose;
 				} catch (cause) {
-					invalidationListeners.delete(entry);
-					lifecycle.disposeAll(watcherDisposers).catch(() => void 0);
+					try {
+						await subscription.dispose();
+					} catch (cleanupError) {
+						throw new AggregateError([cause, cleanupError], "Resource subscription setup and cleanup failed");
+					}
 					throw cause;
 				}
-				return lifecycle.track(async () => {
-					invalidationListeners.delete(entry);
-					await lifecycle.disposeAll(watcherDisposers);
-				}, signal);
 			}
 		});
 	});