@context-action/core 1.0.0 → 1.1.1

package/dist/index.js

@@ -1414,7 +1414,7 @@ var ActionRegister = class {
 				return newUnregister;
 			} else {
 				if (!existing) throw new Error("Internal error: existing handler should be defined in duplicate handler block");
-				this.log(`Handler duplicate ignored, returning existing unregister: ${String(action)}`, {
+				this.log(`Handler duplicate ignored, returning no-op unregister: ${String(action)}`, {
 					handlerId,
 					existingPriority: existing.config.priority,
 					newPriority: config.priority,
@@ -1422,12 +1422,7 @@ var ActionRegister = class {
 					newBlocking: config.blocking,
 					note: "Use replaceExisting:true to replace"
 				}, "warn");
-				if (existingUnregister) return existingUnregister;
-				else {
-					const newUnregister = this.createUnregisterFunction(action, handlerId, existing);
-					actionUnregisterFunctions.set(handlerId, newUnregister);
-					return newUnregister;
-				}
+				return () => {};
 			}
 		}
 		pipeline.push(registration);
@@ -1451,7 +1446,8 @@ var ActionRegister = class {
 		const attemptState = { count: 0 };
 		const plan = this.resolveDispatchPlan(action, options);
 		const hasTimingGuard = plan.debounceMs !== void 0 || plan.throttleMs !== void 0;
-		let observerNotified = false;
+		const notifiedObservers = /* @__PURE__ */ new Set();
+		const notifiedObserverOutcomes = /* @__PURE__ */ new Set();
 		let terminalErrorReported = false;
 		const reportTerminalError = (error) => {
 			if (terminalErrorReported) return;
@@ -1459,9 +1455,9 @@ var ActionRegister = class {
 			this.invokeErrorHandler(error, action, payload, options, attemptState.count);
 		};
 		const notifyObservers = async (event) => {
-			if (observerNotified) return;
-			observerNotified = true;
-			await this.executeObservers(action, plan, event);
+			if (notifiedObserverOutcomes.has(event.outcome)) return;
+			notifiedObserverOutcomes.add(event.outcome);
+			await this.executeObservers(action, plan, event, notifiedObservers);
 		};
 		const pipelineOperation = async () => {
 			const guard = plan.guards.length > 0 ? await this.executeGuardPhase(action, payload, timeoutScope.options, plan, dispatchHandlerPromises) : {
@@ -1496,6 +1492,18 @@ var ActionRegister = class {
 					this.cleanupOneTimeHandlers(action, executedHandlers, dispatchHandlerPromises);
 				}
 			}, timeoutScope.options, attemptState, (result) => result.outcome === "failed", () => this.getAttemptHandlers(action, plan).length > 0, void 0, this.shouldDrainBeforeRetry(plan, timeoutScope.options) ? () => this.drainAttemptHandlers(dispatchHandlerPromises) : void 0);
+			if (timeoutScope.options?.signal?.aborted) {
+				if (timeoutScope.options.signal.reason instanceof ActionTimeoutError) throw timeoutScope.options.signal.reason;
+				await notifyObservers({
+					action: String(action),
+					payload: guard.payload,
+					outcome: "cancelled",
+					result: void 0,
+					errors: execution.errors,
+					signal: timeoutScope.options.signal
+				});
+				return;
+			}
 			if (execution.outcome === "failed") throw execution.errors[execution.errors.length - 1]?.error ?? /* @__PURE__ */ new Error(`Action "${String(action)}" failed`);
 			const result = this.processResults(execution.results, execution.terminated, execution.terminated ? execution.result : void 0, options?.result);
 			await notifyObservers({
@@ -1595,7 +1603,7 @@ var ActionRegister = class {
 		}
 		const observedPromise = this.raceWithTimeout(observedDispatchPromise, timeoutScope, dispatchHandlerPromises).catch(async (error) => {
 			reportTerminalError(error);
-			if (!observerNotified) await this.trackGlobalHandlerPromise(notifyObservers({
+			this.trackGlobalHandlerPromise(notifyObservers({
 				action: String(action),
 				payload,
 				outcome: "failed",
@@ -1607,7 +1615,9 @@ var ActionRegister = class {
 					severity: "blocking"
 				}],
 				signal: timeoutScope.options?.signal
-			}));
+			})).catch((observerError) => {
+				this.log(`Failure observer delivery failed for ${String(action)}`, observerError, "warn");
+			});
 			throw error;
 		});
 		observedPromise.catch(() => {});
@@ -1955,12 +1965,18 @@ var ActionRegister = class {
 	/** Observers run after the canonical result has been constructed. Their
 	* failures are isolated from that immutable result; detached observers are
 	* still tracked for registry shutdown. */
-	async executeObservers(action, plan, event) {
+	async executeObservers(action, plan, event, notifiedObservers = /* @__PURE__ */ new Set()) {
 		const observerEvent = this.safeSnapshotObserverEvent(event);
+		const selectedObservers = [];
 		for (const [registration, observerEntry] of this.getObservers(action, plan)) {
+			if (notifiedObservers.has(registration)) continue;
 			const successful = observerEvent.outcome === "completed" || observerEvent.outcome === "completed_with_errors";
 			if (observerEntry.when === "success" && !successful) continue;
 			if (observerEntry.when === "failure" && successful) continue;
+			notifiedObservers.add(registration);
+			selectedObservers.push([registration, observerEntry]);
+		}
+		for (const [registration, observerEntry] of selectedObservers) {
 			let shouldRun = true;
 			try {
 				shouldRun = registration.config.condition?.(observerEvent.payload) ?? true;
@@ -2227,13 +2243,16 @@ var ActionRegister = class {
 					this.cleanupOneTimeHandlers(action, executedHandlers, dispatchHandlerPromises);
 				}
 			}, timeoutScope.options, attemptState, (result) => result.outcome === "failed", () => this.getAttemptHandlers(action, plan).length > 0, retryTelemetry, this.shouldDrainBeforeRetry(plan, timeoutScope.options) ? () => this.drainAttemptHandlers(dispatchHandlerPromises) : void 0);
-			if (timeoutScope.options?.signal?.aborted) return {
-				...rawExecution,
-				success: false,
-				aborted: true,
-				abortReason: typeof timeoutScope.options.signal.reason === "string" ? timeoutScope.options.signal.reason : "Action dispatch aborted by signal",
-				outcome: "cancelled"
-			};
+			if (timeoutScope.options?.signal?.aborted) {
+				if (timeoutScope.options.signal.reason instanceof ActionTimeoutError) throw timeoutScope.options.signal.reason;
+				return {
+					...rawExecution,
+					success: false,
+					aborted: true,
+					abortReason: typeof timeoutScope.options.signal.reason === "string" ? timeoutScope.options.signal.reason : "Action dispatch aborted by signal",
+					outcome: "cancelled"
+				};
+			}
 			const executionWithGuards = {
 				...rawExecution,
 				handlers: [...guard.outcomes.map((outcome) => ({
@@ -2294,7 +2313,8 @@ var ActionRegister = class {
 			timeoutScope.onTimeout((error) => queued.cancel(error));
 			return queued.promise;
 		};
-		let observerNotified = false;
+		const notifiedObservers = /* @__PURE__ */ new Set();
+		const notifiedObserverOutcomes = /* @__PURE__ */ new Set();
 		let terminalErrorReported = false;
 		const reportTerminalError = (error) => {
 			if (terminalErrorReported) return;
@@ -2302,9 +2322,9 @@ var ActionRegister = class {
 			this.invokeErrorHandler(error, action, payload, options, attemptState.count);
 		};
 		const notifyObservers = async (event) => {
-			if (observerNotified) return;
-			observerNotified = true;
-			await this.executeObservers(action, plan, event);
+			if (notifiedObserverOutcomes.has(event.outcome)) return;
+			notifiedObserverOutcomes.add(event.outcome);
+			await this.executeObservers(action, plan, event, notifiedObservers);
 		};
 		let dispatchPromise;
 		let observedDispatchPromise;
@@ -2362,7 +2382,7 @@ var ActionRegister = class {
 		}
 		const observedPromise = this.raceWithTimeout(observedDispatchPromise, timeoutScope, dispatchHandlerPromises).catch(async (error) => {
 			reportTerminalError(error);
-			if (!observerNotified) await this.trackGlobalHandlerPromise(notifyObservers({
+			this.trackGlobalHandlerPromise(notifyObservers({
 				action: String(action),
 				payload: observerPayload,
 				outcome: "failed",
@@ -2374,7 +2394,9 @@ var ActionRegister = class {
 					severity: "blocking"
 				}],
 				signal: timeoutScope.options?.signal
-			}));
+			})).catch((observerError) => {
+				this.log(`Failure observer delivery failed for ${String(action)}`, observerError, "warn");
+			});
 			throw error;
 		});
 		observedPromise.catch(() => {});
@@ -2614,7 +2636,7 @@ var ActionRegister = class {
 		if (resultOptions.maxResults !== void 0 && (!Number.isSafeInteger(resultOptions.maxResults) || resultOptions.maxResults < 0)) throw new RangeError("maxResults must be a non-negative safe integer.");
 	}
 	processResults(results, terminated, terminationResult, resultOptions) {
-		if (terminated && terminationResult !== void 0) return terminationResult;
+		if (terminated) return terminationResult;
 		if (!resultOptions) return results.length > 0 ? results[results.length - 1] : void 0;
 		if (!resultOptions.collect && !resultOptions.strategy) return;
 		const collectedResults = results.filter((result) => result !== void 0);
@@ -2988,7 +3010,7 @@ var ActionRegister = class {
 	cancelPendingDispatches() {
 		this.dispatchQueue?.clear({ rejectPending: true });
 	}
-	beginShutdown() {
+	beginShutdown(deferCleanup = false) {
 		if (this.destroyAsyncPromise) return this.destroyAsyncPromise;
 		if (this.lifecycleState === "destroyed") {
 			this.destroyAsyncPromise = Promise.resolve();
@@ -3008,7 +3030,7 @@ var ActionRegister = class {
 			rejectPending: true,
 			reason: shutdownError
 		});
-		if (this.dispatchConstructionDepth === 0 && this.activeDispatches.size === 0 && this.activeHandlerPromises.size === 0) {
+		if (!deferCleanup && this.dispatchConstructionDepth === 0 && this.activeDispatches.size === 0 && this.activeHandlerPromises.size === 0) {
 			this.finalizeDestroy();
 			resolveShutdown();
 			return this.destroyAsyncPromise;
@@ -3046,13 +3068,18 @@ var ActionRegister = class {
 	* Begin terminal shutdown and resolve after all started handlers have settled
 	* and their registered cleanup functions have run.
 	*
+	* `deferCleanup` closes the register synchronously while deferring final
+	* registered cleanup until the next microtask. This is useful for React
+	* commit phases that must invalidate stale dispatchers immediately without
+	* invoking user cleanup code inside the commit hook itself.
+	*
 	* Repeated calls return the same promise. New registrations and dispatches are
 	* rejected as soon as shutdown begins.
 	*
 	* @public
 	*/
-	destroyAsync() {
-		return this.beginShutdown();
+	destroyAsync(options = {}) {
+		return this.beginShutdown(options.deferCleanup ?? false);
 	}
 };