@btravstack/core 0.7.0 → 0.9.0

package/README.md

@@ -44,7 +44,10 @@ class Greeter extends Port("Greeter")<{
 
 const AppModule = Module("App")({
   provides: [
-    Provider(Greeter)({ value: { greet: (name: string) => `hello, ${name}` } }),
+    Provider(Greeter)({
+      inject: {},
+      value: { greet: (name: string) => `hello, ${name}` },
+    }),
   ],
   exports: [Greeter],
 });
@@ -94,7 +97,7 @@ class Ticker extends RuntimePort<Runtime<typeof Greeter>> {}
 
 const TickerApp = Module("TickerApp")({
   imports: [AppModule],
-  provides: [Provider(Ticker)({ value: ticker })],
+  provides: [Provider(Ticker)({ inject: {}, value: ticker })],
   exports: [Greeter, Ticker],
 });
 

package/dist/index.cjs

@@ -38,18 +38,25 @@ var HealthChecks = class extends _btravstack_di.Port.many("HealthChecks") {};
 *
 * Each check's failure is recovered into a component line BEFORE `allAsync`
 * sees it, so a failing dependency cannot short-circuit the others: a report
-* naming one component is worth less than one naming all of them. What
-* survives to `allAsync`'s error channel is a `Defect` alone — a check that
-* threw rather than answered, which is a bug in the check.
+* naming one component is worth less than one naming all of them. A check
+* that throws rather than answers is a bug in the check, and it is folded in
+* too: each check is STARTED inside the pipeline, so a synchronous throw and
+* a defecting `AsyncResult` alike are recovered into an unhealthy line —
+* escaped, the first would reach the kernel's own `uncaughtException` handler
+* and the second would leave `/healthz` hanging with nothing written.
 */
-const runHealthChecks = (checks) => (0, unthrown.allAsync)(checks.map((health) => health.check().map(() => ({
+const runHealthChecks = (checks) => (0, unthrown.allAsync)(checks.map((health) => (0, unthrown.OkAsync)().flatMap(() => health.check()).map(() => ({
 	name: health.name,
 	status: "healthy"
 })).recoverErrCases((matcher) => matcher.with(unthrown.P.tag("HealthCheckFailed"), (error) => ({
 	name: health.name,
 	status: "unhealthy",
 	reason: error.reason
-}))))).map((components) => ({
+}))).recoverDefect((cause) => (0, unthrown.Ok)({
+	name: health.name,
+	status: "unhealthy",
+	reason: String(cause)
+})))).map((components) => ({
 	status: components.every((c) => c.status === "healthy") ? "healthy" : "unhealthy",
 	components
 }));
@@ -478,7 +485,10 @@ const start = (module, options = {}) => {
 	});
 	const root = (0, _btravstack_di.Module)("Kernel")({
 		imports: providesEnv(module) ? [module] : [module, (0, _btravstack_di.Module)("Environment")({
-			provides: [(0, _btravstack_di.Provider)(_btravstack_config.Env)({ value: env })],
+			provides: [(0, _btravstack_di.Provider)(_btravstack_config.Env)({
+				inject: {},
+				value: env
+			})],
 			exports: [_btravstack_config.Env]
 		})],
 		exports: [module]

package/dist/index.d.cts

@@ -74,9 +74,12 @@ type HealthReport = {
  *
  * Each check's failure is recovered into a component line BEFORE `allAsync`
  * sees it, so a failing dependency cannot short-circuit the others: a report
- * naming one component is worth less than one naming all of them. What
- * survives to `allAsync`'s error channel is a `Defect` alone — a check that
- * threw rather than answered, which is a bug in the check.
+ * naming one component is worth less than one naming all of them. A check
+ * that throws rather than answers is a bug in the check, and it is folded in
+ * too: each check is STARTED inside the pipeline, so a synchronous throw and
+ * a defecting `AsyncResult` alike are recovered into an unhealthy line —
+ * escaped, the first would reach the kernel's own `uncaughtException` handler
+ * and the second would leave `/healthz` hanging with nothing written.
  */
 declare const runHealthChecks: (checks: readonly HealthCheck[]) => AsyncResult<HealthReport, never>;
 //#endregion
@@ -439,9 +442,11 @@ type StartOptions<UnitX = never, UnitNeeds = never> = {
    */
   readonly env?: Environment;
   /**
-   * A module forked around **every unit**: built as the unit opens, torn down
-   * as it closes — while the unit's ambient record is still open — reading
-   * anything the application context carries.
+   * A module forked around **every unit** — a unit being one bounded piece of
+   * work, whatever the transport calls it: an HTTP request, a Temporal
+   * activity, an AMQP delivery. Built as the unit opens, torn down as it
+   * closes — while the unit's ambient record is still open — reading anything
+   * the application context carries.
    *
    * A failing unit finaliser is reported as a `teardownError` event and never
    * in `ExitReport.teardownErrors`. With this option the unit's work runs only

package/dist/index.d.mts

@@ -74,9 +74,12 @@ type HealthReport = {
  *
  * Each check's failure is recovered into a component line BEFORE `allAsync`
  * sees it, so a failing dependency cannot short-circuit the others: a report
- * naming one component is worth less than one naming all of them. What
- * survives to `allAsync`'s error channel is a `Defect` alone — a check that
- * threw rather than answered, which is a bug in the check.
+ * naming one component is worth less than one naming all of them. A check
+ * that throws rather than answers is a bug in the check, and it is folded in
+ * too: each check is STARTED inside the pipeline, so a synchronous throw and
+ * a defecting `AsyncResult` alike are recovered into an unhealthy line —
+ * escaped, the first would reach the kernel's own `uncaughtException` handler
+ * and the second would leave `/healthz` hanging with nothing written.
  */
 declare const runHealthChecks: (checks: readonly HealthCheck[]) => AsyncResult<HealthReport, never>;
 //#endregion
@@ -439,9 +442,11 @@ type StartOptions<UnitX = never, UnitNeeds = never> = {
    */
   readonly env?: Environment;
   /**
-   * A module forked around **every unit**: built as the unit opens, torn down
-   * as it closes — while the unit's ambient record is still open — reading
-   * anything the application context carries.
+   * A module forked around **every unit** — a unit being one bounded piece of
+   * work, whatever the transport calls it: an HTTP request, a Temporal
+   * activity, an AMQP delivery. Built as the unit opens, torn down as it
+   * closes — while the unit's ambient record is still open — reading anything
+   * the application context carries.
    *
    * A failing unit finaliser is reported as a `teardownError` event and never
    * in `ExitReport.teardownErrors`. With this option the unit's work runs only

package/dist/index.mjs

@@ -37,18 +37,25 @@ var HealthChecks = class extends Port.many("HealthChecks") {};
 *
 * Each check's failure is recovered into a component line BEFORE `allAsync`
 * sees it, so a failing dependency cannot short-circuit the others: a report
-* naming one component is worth less than one naming all of them. What
-* survives to `allAsync`'s error channel is a `Defect` alone — a check that
-* threw rather than answered, which is a bug in the check.
+* naming one component is worth less than one naming all of them. A check
+* that throws rather than answers is a bug in the check, and it is folded in
+* too: each check is STARTED inside the pipeline, so a synchronous throw and
+* a defecting `AsyncResult` alike are recovered into an unhealthy line —
+* escaped, the first would reach the kernel's own `uncaughtException` handler
+* and the second would leave `/healthz` hanging with nothing written.
 */
-const runHealthChecks = (checks) => allAsync(checks.map((health) => health.check().map(() => ({
+const runHealthChecks = (checks) => allAsync(checks.map((health) => OkAsync().flatMap(() => health.check()).map(() => ({
 	name: health.name,
 	status: "healthy"
 })).recoverErrCases((matcher) => matcher.with(P.tag("HealthCheckFailed"), (error) => ({
 	name: health.name,
 	status: "unhealthy",
 	reason: error.reason
-}))))).map((components) => ({
+}))).recoverDefect((cause) => Ok({
+	name: health.name,
+	status: "unhealthy",
+	reason: String(cause)
+})))).map((components) => ({
 	status: components.every((c) => c.status === "healthy") ? "healthy" : "unhealthy",
 	components
 }));
@@ -477,7 +484,10 @@ const start = (module, options = {}) => {
 	});
 	const root = Module("Kernel")({
 		imports: providesEnv(module) ? [module] : [module, Module("Environment")({
-			provides: [Provider(Env)({ value: env })],
+			provides: [Provider(Env)({
+				inject: {},
+				value: env
+			})],
 			exports: [Env]
 		})],
 		exports: [module]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@btravstack/core",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "The application kernel: boot a di module into a running process, and stop it without losing work",
   "keywords": [
     "application",
@@ -46,20 +46,20 @@
   },
   "devDependencies": {
     "@btravstack/tsconfig": "0.2.0",
-    "@types/node": "26.2.0",
+    "@types/node": "26.4.0",
     "@unthrown/vitest": "5.7.0",
     "@vitest/coverage-v8": "4.1.11",
     "tsdown": "0.22.14",
     "typescript": "7.0.2",
     "unthrown": "5.7.0",
     "vitest": "4.1.11",
-    "@btravstack/config": "0.7.0",
-    "@btravstack/di": "0.7.0"
+    "@btravstack/config": "0.9.0",
+    "@btravstack/di": "0.9.0"
   },
   "peerDependencies": {
     "unthrown": "^5.0.0",
-    "@btravstack/config": "^0.7.0",
-    "@btravstack/di": "^0.7.0"
+    "@btravstack/config": "^0.9.0",
+    "@btravstack/di": "^0.9.0"
   },
   "engines": {
     "node": ">=22"