@btravstack/core 0.28.0 → 0.30.0

package/dist/index.cjs

@@ -124,14 +124,18 @@ const noObserver = () => () => {};
 * matters because the settling call sites are error paths, where a `tap` and a
 * `tapFailure` on the same chain, or a retry, is exactly the shape that fires
 * twice and doubles a failure count.
+*
+* A broken observer is dropped independently, on startup and settlement. No
+* recursive reporting is attempted: telemetry must never alter the operation
+* or prevent another observer from settling.
 */
 const observe = (observers, operation) => {
-	const settlers = observers.map((observer) => observer(operation));
+	const settlers = observers.map((observer) => (0, unthrown.fromSafeThrowable)(observer)(operation).recoverDefect(() => (0, unthrown.Ok)(noObserver())).get());
 	let done = false;
 	return (settled) => {
 		if (done) return;
 		done = true;
-		for (const settle of settlers) settle(settled);
+		for (const settle of settlers) (0, unthrown.fromSafeThrowable)(settle)(settled).recoverDefect(() => (0, unthrown.Ok)()).get();
 	};
 };
 /**
@@ -143,14 +147,21 @@ const observe = (observers, operation) => {
 *
 * `settled` replaces either default where a starter has more to say: `ok`
 * receives the value (a cache reports a hit or a miss), `failure` the
-* `FailureView` (a store reports a missing object as an ordinary answer).
+* `FailureView` (a store reports a missing object as an ordinary answer). A
+* throwing shaping hook is dropped and the ordinary settlement is used.
 */
 const observed = (observers, operation, call, settled = {}) => {
 	const settle = observe(observers, operation);
-	return call().tap((value) => settle(settled.ok?.(value) ?? { outcome: "ok" })).tapFailure((failure) => settle(settled.failure?.(failure) ?? {
-		outcome: "error",
-		cause: failure.tag === "Err" ? failure.error : failure.cause
-	}));
+	return (0, unthrown.OkAsync)().flatMap(call).tap((value) => {
+		const rendered = (0, unthrown.fromSafeThrowable)(() => settled.ok?.(value))().recoverDefect(() => (0, unthrown.Ok)(void 0)).get();
+		settle(rendered ?? { outcome: "ok" });
+	}).tapFailure((failure) => {
+		const rendered = (0, unthrown.fromSafeThrowable)(() => settled.failure?.(failure))().recoverDefect(() => (0, unthrown.Ok)(void 0)).get();
+		settle(rendered ?? {
+			outcome: "error",
+			cause: failure.tag === "Err" ? failure.error : failure.cause
+		});
+	});
 };
 //#endregion
 //#region src/clock.ts
@@ -520,6 +531,7 @@ const createUnitRegistry = () => {
 				} finally {
 					open.delete(controller);
 					closedCount += 1;
+					controller.abort(new DOMException("The unit has settled", "AbortError"));
 					settleIfIdle();
 				}
 			})).flatMap((result) => result);

package/dist/index.d.cts

@@ -309,6 +309,10 @@ export declare const noObserver: () => Settle;
  * matters because the settling call sites are error paths, where a `tap` and a
  * `tapFailure` on the same chain, or a retry, is exactly the shape that fires
  * twice and doubles a failure count.
+ *
+ * A broken observer is dropped independently, on startup and settlement. No
+ * recursive reporting is attempted: telemetry must never alter the operation
+ * or prevent another observer from settling.
  */
 export declare const observe: (observers: readonly ((operation: Operation) => Settle)[], operation: Operation) => Settle;
 /**
@@ -320,7 +324,8 @@ export declare const observe: (observers: readonly ((operation: Operation) => Se
  *
  * `settled` replaces either default where a starter has more to say: `ok`
  * receives the value (a cache reports a hit or a miss), `failure` the
- * `FailureView` (a store reports a missing object as an ordinary answer).
+ * `FailureView` (a store reports a missing object as an ordinary answer). A
+ * throwing shaping hook is dropped and the ordinary settlement is used.
  */
 export declare const observed: <T, E>(observers: readonly ((operation: Operation) => Settle)[], operation: Operation, call: () => AsyncResult<T, E>, settled?: {
   readonly ok?: (value: T) => Settled;
@@ -340,7 +345,11 @@ export declare const systemClock: Clock;
  * record of **data about this unit**, and never a service.
  *
  * `signal` is the same `AbortSignal` the work callback receives — aborted at
- * the drain deadline, or at once on a path that skips the drain. It is here
+ * the drain deadline, at once on a path that skips the drain, and once the
+ * unit has settled, so work that outlives its unit — an HTTP handler whose
+ * client disconnected — is told to stop. The settle abort's `reason` is an
+ * `AbortError` `DOMException` whose message is `"The unit has settled"`; the
+ * kernel's own aborts keep the default reason. It is here
  * because the callback is not always where the work is: a middleware-shaped
  * runtime opens the unit around a call whose arguments it does not own. A
  * transport's own cancellation is a different clock, not this one.
@@ -481,6 +490,11 @@ export declare class RuntimeStartFailed extends RuntimeStartFailed_base<{
  * moment it holds the unit's input; the kernel closes that scope when the
  * unit settles, after the response is flushed. Work that subscribes to an
  * event after a `fork` must first check whether it already fired.
+ *
+ * `signal` aborts at the drain deadline, at once when the drain is skipped,
+ * and once the unit settles — after its scope has closed — so work the
+ * runtime left running past the unit, such as an HTTP handler whose client
+ * disconnected, is told to stop. Only the first two count as `abandoned`.
  */
 type RunUnit<Resolves extends AnyPort> = <T, E>(meta: UnitMeta, work: (unit: UnitHost<Resolves>, signal: AbortSignal) => ReturnType<UnitWork<T, E>>) => AsyncResult<T, E>;
 /**

package/dist/index.d.mts

@@ -309,6 +309,10 @@ export declare const noObserver: () => Settle;
  * matters because the settling call sites are error paths, where a `tap` and a
  * `tapFailure` on the same chain, or a retry, is exactly the shape that fires
  * twice and doubles a failure count.
+ *
+ * A broken observer is dropped independently, on startup and settlement. No
+ * recursive reporting is attempted: telemetry must never alter the operation
+ * or prevent another observer from settling.
  */
 export declare const observe: (observers: readonly ((operation: Operation) => Settle)[], operation: Operation) => Settle;
 /**
@@ -320,7 +324,8 @@ export declare const observe: (observers: readonly ((operation: Operation) => Se
  *
  * `settled` replaces either default where a starter has more to say: `ok`
  * receives the value (a cache reports a hit or a miss), `failure` the
- * `FailureView` (a store reports a missing object as an ordinary answer).
+ * `FailureView` (a store reports a missing object as an ordinary answer). A
+ * throwing shaping hook is dropped and the ordinary settlement is used.
  */
 export declare const observed: <T, E>(observers: readonly ((operation: Operation) => Settle)[], operation: Operation, call: () => AsyncResult<T, E>, settled?: {
   readonly ok?: (value: T) => Settled;
@@ -340,7 +345,11 @@ export declare const systemClock: Clock;
  * record of **data about this unit**, and never a service.
  *
  * `signal` is the same `AbortSignal` the work callback receives — aborted at
- * the drain deadline, or at once on a path that skips the drain. It is here
+ * the drain deadline, at once on a path that skips the drain, and once the
+ * unit has settled, so work that outlives its unit — an HTTP handler whose
+ * client disconnected — is told to stop. The settle abort's `reason` is an
+ * `AbortError` `DOMException` whose message is `"The unit has settled"`; the
+ * kernel's own aborts keep the default reason. It is here
  * because the callback is not always where the work is: a middleware-shaped
  * runtime opens the unit around a call whose arguments it does not own. A
  * transport's own cancellation is a different clock, not this one.
@@ -481,6 +490,11 @@ export declare class RuntimeStartFailed extends RuntimeStartFailed_base<{
  * moment it holds the unit's input; the kernel closes that scope when the
  * unit settles, after the response is flushed. Work that subscribes to an
  * event after a `fork` must first check whether it already fired.
+ *
+ * `signal` aborts at the drain deadline, at once when the drain is skipped,
+ * and once the unit settles — after its scope has closed — so work the
+ * runtime left running past the unit, such as an HTTP handler whose client
+ * disconnected, is told to stop. Only the first two count as `abandoned`.
  */
 type RunUnit<Resolves extends AnyPort> = <T, E>(meta: UnitMeta, work: (unit: UnitHost<Resolves>, signal: AbortSignal) => ReturnType<UnitWork<T, E>>) => AsyncResult<T, E>;
 /**

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { Module, Port, Provider } from "@btravstack/di";
-import { Err, Ok, OkAsync, P, TaggedError, allAsync, fromSafePromise } from "unthrown";
+import { Err, Ok, OkAsync, P, TaggedError, allAsync, fromSafePromise, fromSafeThrowable } from "unthrown";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { Config, ConfigInvalid, Env } from "@btravstack/config";
 import { createServer } from "node:http";
@@ -123,14 +123,18 @@ const noObserver = () => () => {};
 * matters because the settling call sites are error paths, where a `tap` and a
 * `tapFailure` on the same chain, or a retry, is exactly the shape that fires
 * twice and doubles a failure count.
+*
+* A broken observer is dropped independently, on startup and settlement. No
+* recursive reporting is attempted: telemetry must never alter the operation
+* or prevent another observer from settling.
 */
 const observe = (observers, operation) => {
-	const settlers = observers.map((observer) => observer(operation));
+	const settlers = observers.map((observer) => fromSafeThrowable(observer)(operation).recoverDefect(() => Ok(noObserver())).get());
 	let done = false;
 	return (settled) => {
 		if (done) return;
 		done = true;
-		for (const settle of settlers) settle(settled);
+		for (const settle of settlers) fromSafeThrowable(settle)(settled).recoverDefect(() => Ok()).get();
 	};
 };
 /**
@@ -142,14 +146,21 @@ const observe = (observers, operation) => {
 *
 * `settled` replaces either default where a starter has more to say: `ok`
 * receives the value (a cache reports a hit or a miss), `failure` the
-* `FailureView` (a store reports a missing object as an ordinary answer).
+* `FailureView` (a store reports a missing object as an ordinary answer). A
+* throwing shaping hook is dropped and the ordinary settlement is used.
 */
 const observed = (observers, operation, call, settled = {}) => {
 	const settle = observe(observers, operation);
-	return call().tap((value) => settle(settled.ok?.(value) ?? { outcome: "ok" })).tapFailure((failure) => settle(settled.failure?.(failure) ?? {
-		outcome: "error",
-		cause: failure.tag === "Err" ? failure.error : failure.cause
-	}));
+	return OkAsync().flatMap(call).tap((value) => {
+		const rendered = fromSafeThrowable(() => settled.ok?.(value))().recoverDefect(() => Ok(void 0)).get();
+		settle(rendered ?? { outcome: "ok" });
+	}).tapFailure((failure) => {
+		const rendered = fromSafeThrowable(() => settled.failure?.(failure))().recoverDefect(() => Ok(void 0)).get();
+		settle(rendered ?? {
+			outcome: "error",
+			cause: failure.tag === "Err" ? failure.error : failure.cause
+		});
+	});
 };
 //#endregion
 //#region src/clock.ts
@@ -519,6 +530,7 @@ const createUnitRegistry = () => {
 				} finally {
 					open.delete(controller);
 					closedCount += 1;
+					controller.abort(new DOMException("The unit has settled", "AbortError"));
 					settleIfIdle();
 				}
 			})).flatMap((result) => result);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@btravstack/core",
-  "version": "0.28.0",
+  "version": "0.30.0",
   "description": "The application kernel: boot a di module into a running process, and stop it without losing work",
   "keywords": [
     "application",
@@ -45,8 +45,8 @@
     "./package.json": "./package.json"
   },
   "devDependencies": {
-    "@btravstack/config": "0.28.0",
-    "@btravstack/di": "0.28.0",
+    "@btravstack/config": "0.30.0",
+    "@btravstack/di": "0.30.0",
     "@btravstack/tsconfig": "0.4.0",
     "@stryker-mutator/core": "10.0.0",
     "@stryker-mutator/vitest-runner": "10.0.0",
@@ -60,8 +60,8 @@
     "vitest": "5.0.3"
   },
   "peerDependencies": {
-    "@btravstack/config": "^0.28.0",
-    "@btravstack/di": "^0.28.0",
+    "@btravstack/config": "^0.30.0",
+    "@btravstack/di": "^0.30.0",
     "unthrown": "^5.0.0"
   },
   "engines": {