@krak-stack/registry 0.1.17 → 0.1.19

package/README.md

@@ -33,6 +33,11 @@ import { Query } from "@krak-stack/registry/query";
 import { createSeo } from "@krak-stack/registry/seo";
 import { FileExtractionService } from "@krak-stack/registry/service-file-extraction";
 import { FileExtractedTextSchema } from "@krak-stack/registry/service-file-extraction/schema";
+import {
+  HealthApiGroup,
+  healthHandler,
+  HealthService,
+} from "@krak-stack/registry/service-health";
 import { NotificationService } from "@krak-stack/registry/service-notification";
 ```
 

package/dist/lib/httpapi-cli.d.ts

@@ -1,4 +1,4 @@
-import { Context, Effect, FileSystem, Layer, Path, Stdio, Terminal } from "effect";
+import { Cause, Context, Effect, FileSystem, Layer, Path, Stdio, Terminal } from "effect";
 import { Command } from "effect/unstable/cli";
 import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
 import { ApiClient, type ApiClientService } from "./httpapi-client.js";
@@ -19,5 +19,6 @@ export declare const printHttpApiCliResult: (response: unknown, operation: HttpA
 export declare const makeHttpApiCliCommand: () => Effect.Effect<Command.Command<string, {}, {}, unknown, never>, never, ApiClient | HttpApiSpec>;
 export declare const httpApiCliEnvironmentLayer: (args: ReadonlyArray<string>) => Layer.Layer<ChildProcessSpawner | FileSystem.FileSystem | Path.Path | Stdio.Stdio | Terminal.Terminal, never, never>;
 export declare const httpApiCli: (args?: string[]) => Effect.Effect<void, unknown, HttpApiCli | Command.Environment>;
+export declare const formatHttpApiCliCause: <E>(cause: Cause.Cause<E>) => string;
 export declare const runHttpApiCli: <E>(layer: Layer.Layer<HttpApiCli, E>, args?: string[]) => void;
 export {};

package/dist/lib/httpapi-cli.js

@@ -1,8 +1,10 @@
 // ../../src/lib/httpapi-cli.ts
 import {
+  Cause,
   Console,
   Context as Context3,
   Effect as Effect3,
+  Exit,
   FileSystem,
   Layer as Layer3,
   Path,
@@ -15,13 +17,22 @@ import { Command, Flag } from "effect/unstable/cli";
 import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
 
 // ../../src/lib/httpapi-client.ts
-import { Context, Effect, Layer, Schema } from "effect";
+import { Context, Effect, Layer, Schema, SchemaTransformation } from "effect";
 import { HttpClient } from "effect/unstable/http";
 import {
-  HttpApiClient as EffectHttpApiClient
+  HttpApi,
+  HttpApiClient as EffectHttpApiClient,
+  OpenApi
 } from "effect/unstable/httpapi";
+var UndefinedFromNull = Schema.Null.pipe(Schema.decodeTo(Schema.Undefined, SchemaTransformation.transform({
+  decode: () => {
+    return;
+  },
+  encode: () => null
+})));
 var HttpApiOperationResultValue = Schema.suspend(() => Schema.Union([
   Schema.Null,
+  UndefinedFromNull,
   Schema.String,
   Schema.Number,
   Schema.Boolean,
@@ -35,6 +46,37 @@ var HttpApiOperationResult = Schema.Union([
   Schema.Undefined
 ]).annotate({ identifier: "HttpApiOperationResult" });
 var encodeHttpApiOperationResult = Effect.fn("HttpApiClient.encodeOperationResult")((result) => Schema.encodeUnknownEffect(HttpApiOperationResult)(result).pipe(Effect.map((encoded) => encoded ?? null), Effect.mapError((cause) => new Error("HTTP API result is not serializable", { cause }))));
+var reflectedSchema = (schema) => Schema.make(schema.ast);
+var operationResultSchemas = (api) => {
+  const schemas = new Map;
+  HttpApi.reflect(api, {
+    onGroup: () => {
+      return;
+    },
+    onEndpoint: ({ endpoint, group, successes }) => {
+      const operationId = Context.getOrElse(endpoint.annotations, OpenApi.Identifier, () => group.topLevel ? endpoint.identifier : `${group.identifier}.${endpoint.identifier}`);
+      const operationSchemas = Array.from(successes.values()).flat().map(reflectedSchema);
+      if (operationSchemas.length === 1 && operationSchemas[0]) {
+        schemas.set(operationId, operationSchemas[0]);
+      } else if (operationSchemas.length > 1) {
+        schemas.set(operationId, Schema.Union(operationSchemas));
+      }
+    }
+  });
+  return schemas;
+};
+var makeHttpApiOperationResultEncoder = (api) => {
+  const schemas = operationResultSchemas(api);
+  return Effect.fn("HttpApiClient.encodeOperationResultWithSchema")((result, operation) => {
+    const operationId = operation.operation.operationId;
+    const schema = operationId ? schemas.get(operationId) : undefined;
+    if (!schema)
+      return encodeHttpApiOperationResult(result);
+    return Schema.encodeUnknownEffect(schema)(result).pipe(Effect.flatMap(encodeHttpApiOperationResult), Effect.mapError((cause) => new Error("HTTP API result does not match its success schema", {
+      cause
+    })));
+  });
+};
 var GeneratedOperation = Schema.declare((value) => value instanceof Function).annotate({ identifier: "GeneratedOperation" });
 var GeneratedOperationEffect = Schema.declare((value) => Effect.isEffect(value)).annotate({ identifier: "GeneratedOperationEffect" });
 var makeGeneratedClient = (api, http, baseUrl) => EffectHttpApiClient.makeWith(api, {
@@ -70,9 +112,10 @@ var executeGeneratedOperation = Effect.fn("HttpApiClient.executeGeneratedOperati
 class ApiClient extends Context.Service()("ApiClient") {
   static layer = (config) => Layer.effect(this, Effect.gen(function* () {
     const http = yield* HttpClient.HttpClient;
+    const encodeResult = makeHttpApiOperationResultEncoder(config.api);
     const client = yield* makeGeneratedClient(config.api, http, config.baseUrl);
     return {
-      encodeResult: config.encodeResult ?? ((result) => encodeHttpApiOperationResult(result)),
+      encodeResult: config.encodeResult ?? ((result, operation) => encodeResult(result, operation)),
       execute: Effect.fn("ApiClient.execute")(function* (options) {
         return yield* executeGeneratedOperation(client, options);
       })
@@ -90,7 +133,7 @@ import {
   Schema as Schema2,
   SchemaRepresentation
 } from "effect";
-import { HttpApi as HttpApi2, OpenApi } from "effect/unstable/httpapi";
+import { HttpApi as HttpApi2, OpenApi as OpenApi2 } from "effect/unstable/httpapi";
 var JsonObjectSchema = Schema2.Record(Schema2.String, Schema2.Json).annotate({
   identifier: "HttpJsonObject",
   title: "HTTP JSON object",
@@ -263,7 +306,7 @@ var decodeHttpApiOperationInput = Effect2.fn("Http.decodeApiOperationInput")(fun
     query: pickParameters("query")
   };
 });
-var reflectedSchema = (schema) => Schema2.make(schema.ast);
+var reflectedSchema2 = (schema) => Schema2.make(schema.ast);
 var reflectedOperationInputSchemas = (api) => {
   const schemas = new Map;
   HttpApi2.reflect(api, {
@@ -271,17 +314,17 @@ var reflectedOperationInputSchemas = (api) => {
       return;
     },
     onEndpoint: ({ endpoint, group }) => {
-      const operationId = Context2.getOrElse(endpoint.annotations, OpenApi.Identifier, () => group.topLevel ? endpoint.identifier : `${group.identifier}.${endpoint.identifier}`);
+      const operationId = Context2.getOrElse(endpoint.annotations, OpenApi2.Identifier, () => group.topLevel ? endpoint.identifier : `${group.identifier}.${endpoint.identifier}`);
       const fields = {};
       if (endpoint.params)
-        fields.params = reflectedSchema(endpoint.params);
+        fields.params = reflectedSchema2(endpoint.params);
       if (endpoint.query) {
-        fields.query = Schema2.optionalKey(reflectedSchema(endpoint.query));
+        fields.query = Schema2.optionalKey(reflectedSchema2(endpoint.query));
       }
       if (endpoint.headers) {
-        fields.headers = Schema2.optionalKey(reflectedSchema(endpoint.headers));
+        fields.headers = Schema2.optionalKey(reflectedSchema2(endpoint.headers));
       }
-      const payloadSchemas = Array.from(endpoint.payload.values()).flatMap(({ schemas: schemas2 }) => schemas2.map(reflectedSchema));
+      const payloadSchemas = Array.from(endpoint.payload.values()).flatMap(({ schemas: schemas2 }) => schemas2.map(reflectedSchema2));
       if (payloadSchemas.length === 1 && payloadSchemas[0]) {
         fields.body = payloadSchemas[0];
       } else if (payloadSchemas.length > 1) {
@@ -313,7 +356,7 @@ class HttpApiSpec extends Context2.Service()("HttpApiSpec", {
       if (!HttpApi2.isHttpApi(api)) {
         throw new Error("HttpApiSpec requires a valid HttpApi");
       }
-      const spec = OpenApi.fromApi(api);
+      const spec = OpenApi2.fromApi(api);
       const reflectedSchemas = reflectedOperationInputSchemas(api);
       const operations = httpApiOperations({
         spec,
@@ -477,11 +520,17 @@ var httpApiCli = (args = process.argv.slice(2)) => Effect3.gen(function* () {
   const cli = yield* HttpApiCli;
   return yield* cli.run(args);
 });
+var formatHttpApiCliCause = Cause.pretty;
 var runHttpApiCli = (layer, args = process.argv.slice(2)) => {
-  Effect3.runPromise(httpApiCli(args).pipe(Effect3.provide(layer), Effect3.provide(httpApiCliEnvironmentLayer(args)))).catch((error) => {
-    console.error(error instanceof Error ? error.message : error);
-    process.exit(1);
-  });
+  Effect3.runPromiseExit(httpApiCli(args).pipe(Effect3.provide(layer), Effect3.provide(httpApiCliEnvironmentLayer(args)))).then(Exit.match({
+    onSuccess: () => {
+      return;
+    },
+    onFailure: (cause) => {
+      console.error(formatHttpApiCliCause(cause));
+      process.exitCode = 1;
+    }
+  }));
 };
 export {
   runHttpApiCli,
@@ -489,5 +538,6 @@ export {
   makeHttpApiCliCommand,
   httpApiCliEnvironmentLayer,
   httpApiCli,
+  formatHttpApiCliCause,
   HttpApiCli
 };

package/dist/lib/httpapi-client.d.ts

@@ -12,12 +12,13 @@ export type ApiClientExecuteOptions = {
     readonly operation: HttpApiOperationEntry;
     readonly input: HttpApiOperationInput;
 };
-export type HttpApiOperationResultValue = null | string | number | boolean | Date | Uint8Array | ReadonlyArray<HttpApiOperationResultValue> | {
+export type HttpApiOperationResultValue = null | undefined | string | number | boolean | Date | Uint8Array | ReadonlyArray<HttpApiOperationResultValue> | {
     readonly [key: string]: HttpApiOperationResultValue;
 };
 export declare const HttpApiOperationResult: Schema.Union<readonly [Schema.Codec<HttpApiOperationResultValue, Json, never, never>, Schema.Undefined]>;
 export type HttpApiOperationResult = typeof HttpApiOperationResult.Type;
 export declare const encodeHttpApiOperationResult: (result: unknown) => Effect.Effect<string | number | boolean | Schema.JsonArray | Schema.JsonObject | null, Error, never>;
+export declare const makeHttpApiOperationResultEncoder: <Id extends string, Groups extends HttpApiGroup.Constraint>(api: HttpApi.HttpApi<Id, Groups>) => (result: unknown, operation: HttpApiOperationEntry) => Effect.Effect<string | number | boolean | Schema.JsonArray | Schema.JsonObject | null, Error, never>;
 export type ApiClientService = {
     readonly encodeResult: (result: ErrorOptions["cause"], operation: HttpApiOperationEntry) => Effect.Effect<Json, Error>;
     readonly execute: (options: ApiClientExecuteOptions) => Effect.Effect<ErrorOptions["cause"], Error>;

package/dist/lib/httpapi-client.js

@@ -1,11 +1,20 @@
 // ../../src/lib/httpapi-client.ts
-import { Context, Effect, Layer, Schema } from "effect";
+import { Context, Effect, Layer, Schema, SchemaTransformation } from "effect";
 import { HttpClient } from "effect/unstable/http";
 import {
-  HttpApiClient as EffectHttpApiClient
+  HttpApi,
+  HttpApiClient as EffectHttpApiClient,
+  OpenApi
 } from "effect/unstable/httpapi";
+var UndefinedFromNull = Schema.Null.pipe(Schema.decodeTo(Schema.Undefined, SchemaTransformation.transform({
+  decode: () => {
+    return;
+  },
+  encode: () => null
+})));
 var HttpApiOperationResultValue = Schema.suspend(() => Schema.Union([
   Schema.Null,
+  UndefinedFromNull,
   Schema.String,
   Schema.Number,
   Schema.Boolean,
@@ -19,6 +28,37 @@ var HttpApiOperationResult = Schema.Union([
   Schema.Undefined
 ]).annotate({ identifier: "HttpApiOperationResult" });
 var encodeHttpApiOperationResult = Effect.fn("HttpApiClient.encodeOperationResult")((result) => Schema.encodeUnknownEffect(HttpApiOperationResult)(result).pipe(Effect.map((encoded) => encoded ?? null), Effect.mapError((cause) => new Error("HTTP API result is not serializable", { cause }))));
+var reflectedSchema = (schema) => Schema.make(schema.ast);
+var operationResultSchemas = (api) => {
+  const schemas = new Map;
+  HttpApi.reflect(api, {
+    onGroup: () => {
+      return;
+    },
+    onEndpoint: ({ endpoint, group, successes }) => {
+      const operationId = Context.getOrElse(endpoint.annotations, OpenApi.Identifier, () => group.topLevel ? endpoint.identifier : `${group.identifier}.${endpoint.identifier}`);
+      const operationSchemas = Array.from(successes.values()).flat().map(reflectedSchema);
+      if (operationSchemas.length === 1 && operationSchemas[0]) {
+        schemas.set(operationId, operationSchemas[0]);
+      } else if (operationSchemas.length > 1) {
+        schemas.set(operationId, Schema.Union(operationSchemas));
+      }
+    }
+  });
+  return schemas;
+};
+var makeHttpApiOperationResultEncoder = (api) => {
+  const schemas = operationResultSchemas(api);
+  return Effect.fn("HttpApiClient.encodeOperationResultWithSchema")((result, operation) => {
+    const operationId = operation.operation.operationId;
+    const schema = operationId ? schemas.get(operationId) : undefined;
+    if (!schema)
+      return encodeHttpApiOperationResult(result);
+    return Schema.encodeUnknownEffect(schema)(result).pipe(Effect.flatMap(encodeHttpApiOperationResult), Effect.mapError((cause) => new Error("HTTP API result does not match its success schema", {
+      cause
+    })));
+  });
+};
 var GeneratedOperation = Schema.declare((value) => value instanceof Function).annotate({ identifier: "GeneratedOperation" });
 var GeneratedOperationEffect = Schema.declare((value) => Effect.isEffect(value)).annotate({ identifier: "GeneratedOperationEffect" });
 var makeGeneratedClient = (api, http, baseUrl) => EffectHttpApiClient.makeWith(api, {
@@ -54,9 +94,10 @@ var executeGeneratedOperation = Effect.fn("HttpApiClient.executeGeneratedOperati
 class ApiClient extends Context.Service()("ApiClient") {
   static layer = (config) => Layer.effect(this, Effect.gen(function* () {
     const http = yield* HttpClient.HttpClient;
+    const encodeResult = makeHttpApiOperationResultEncoder(config.api);
     const client = yield* makeGeneratedClient(config.api, http, config.baseUrl);
     return {
-      encodeResult: config.encodeResult ?? ((result) => encodeHttpApiOperationResult(result)),
+      encodeResult: config.encodeResult ?? ((result, operation) => encodeResult(result, operation)),
       execute: Effect.fn("ApiClient.execute")(function* (options) {
         return yield* executeGeneratedOperation(client, options);
       })
@@ -64,6 +105,7 @@ class ApiClient extends Context.Service()("ApiClient") {
   }));
 }
 export {
+  makeHttpApiOperationResultEncoder,
   encodeHttpApiOperationResult,
   HttpApiOperationResult,
   ApiClient

package/dist/lib/httpapi-mcp.js

@@ -3,13 +3,22 @@ import { Context as Context3, Effect as Effect3, Layer as Layer3, Option as Opti
 import { McpSchema, McpServer } from "effect/unstable/ai";
 
 // ../../src/lib/httpapi-client.ts
-import { Context, Effect, Layer, Schema } from "effect";
+import { Context, Effect, Layer, Schema, SchemaTransformation } from "effect";
 import { HttpClient } from "effect/unstable/http";
 import {
-  HttpApiClient as EffectHttpApiClient
+  HttpApi,
+  HttpApiClient as EffectHttpApiClient,
+  OpenApi
 } from "effect/unstable/httpapi";
+var UndefinedFromNull = Schema.Null.pipe(Schema.decodeTo(Schema.Undefined, SchemaTransformation.transform({
+  decode: () => {
+    return;
+  },
+  encode: () => null
+})));
 var HttpApiOperationResultValue = Schema.suspend(() => Schema.Union([
   Schema.Null,
+  UndefinedFromNull,
   Schema.String,
   Schema.Number,
   Schema.Boolean,
@@ -23,6 +32,37 @@ var HttpApiOperationResult = Schema.Union([
   Schema.Undefined
 ]).annotate({ identifier: "HttpApiOperationResult" });
 var encodeHttpApiOperationResult = Effect.fn("HttpApiClient.encodeOperationResult")((result) => Schema.encodeUnknownEffect(HttpApiOperationResult)(result).pipe(Effect.map((encoded) => encoded ?? null), Effect.mapError((cause) => new Error("HTTP API result is not serializable", { cause }))));
+var reflectedSchema = (schema) => Schema.make(schema.ast);
+var operationResultSchemas = (api) => {
+  const schemas = new Map;
+  HttpApi.reflect(api, {
+    onGroup: () => {
+      return;
+    },
+    onEndpoint: ({ endpoint, group, successes }) => {
+      const operationId = Context.getOrElse(endpoint.annotations, OpenApi.Identifier, () => group.topLevel ? endpoint.identifier : `${group.identifier}.${endpoint.identifier}`);
+      const operationSchemas = Array.from(successes.values()).flat().map(reflectedSchema);
+      if (operationSchemas.length === 1 && operationSchemas[0]) {
+        schemas.set(operationId, operationSchemas[0]);
+      } else if (operationSchemas.length > 1) {
+        schemas.set(operationId, Schema.Union(operationSchemas));
+      }
+    }
+  });
+  return schemas;
+};
+var makeHttpApiOperationResultEncoder = (api) => {
+  const schemas = operationResultSchemas(api);
+  return Effect.fn("HttpApiClient.encodeOperationResultWithSchema")((result, operation) => {
+    const operationId = operation.operation.operationId;
+    const schema = operationId ? schemas.get(operationId) : undefined;
+    if (!schema)
+      return encodeHttpApiOperationResult(result);
+    return Schema.encodeUnknownEffect(schema)(result).pipe(Effect.flatMap(encodeHttpApiOperationResult), Effect.mapError((cause) => new Error("HTTP API result does not match its success schema", {
+      cause
+    })));
+  });
+};
 var GeneratedOperation = Schema.declare((value) => value instanceof Function).annotate({ identifier: "GeneratedOperation" });
 var GeneratedOperationEffect = Schema.declare((value) => Effect.isEffect(value)).annotate({ identifier: "GeneratedOperationEffect" });
 var makeGeneratedClient = (api, http, baseUrl) => EffectHttpApiClient.makeWith(api, {
@@ -58,9 +98,10 @@ var executeGeneratedOperation = Effect.fn("HttpApiClient.executeGeneratedOperati
 class ApiClient extends Context.Service()("ApiClient") {
   static layer = (config) => Layer.effect(this, Effect.gen(function* () {
     const http = yield* HttpClient.HttpClient;
+    const encodeResult = makeHttpApiOperationResultEncoder(config.api);
     const client = yield* makeGeneratedClient(config.api, http, config.baseUrl);
     return {
-      encodeResult: config.encodeResult ?? ((result) => encodeHttpApiOperationResult(result)),
+      encodeResult: config.encodeResult ?? ((result, operation) => encodeResult(result, operation)),
       execute: Effect.fn("ApiClient.execute")(function* (options) {
         return yield* executeGeneratedOperation(client, options);
       })
@@ -78,7 +119,7 @@ import {
   Schema as Schema2,
   SchemaRepresentation
 } from "effect";
-import { HttpApi as HttpApi2, OpenApi } from "effect/unstable/httpapi";
+import { HttpApi as HttpApi2, OpenApi as OpenApi2 } from "effect/unstable/httpapi";
 var JsonObjectSchema = Schema2.Record(Schema2.String, Schema2.Json).annotate({
   identifier: "HttpJsonObject",
   title: "HTTP JSON object",
@@ -251,7 +292,7 @@ var decodeHttpApiOperationInput = Effect2.fn("Http.decodeApiOperationInput")(fun
     query: pickParameters("query")
   };
 });
-var reflectedSchema = (schema) => Schema2.make(schema.ast);
+var reflectedSchema2 = (schema) => Schema2.make(schema.ast);
 var reflectedOperationInputSchemas = (api) => {
   const schemas = new Map;
   HttpApi2.reflect(api, {
@@ -259,17 +300,17 @@ var reflectedOperationInputSchemas = (api) => {
       return;
     },
     onEndpoint: ({ endpoint, group }) => {
-      const operationId = Context2.getOrElse(endpoint.annotations, OpenApi.Identifier, () => group.topLevel ? endpoint.identifier : `${group.identifier}.${endpoint.identifier}`);
+      const operationId = Context2.getOrElse(endpoint.annotations, OpenApi2.Identifier, () => group.topLevel ? endpoint.identifier : `${group.identifier}.${endpoint.identifier}`);
       const fields = {};
       if (endpoint.params)
-        fields.params = reflectedSchema(endpoint.params);
+        fields.params = reflectedSchema2(endpoint.params);
       if (endpoint.query) {
-        fields.query = Schema2.optionalKey(reflectedSchema(endpoint.query));
+        fields.query = Schema2.optionalKey(reflectedSchema2(endpoint.query));
       }
       if (endpoint.headers) {
-        fields.headers = Schema2.optionalKey(reflectedSchema(endpoint.headers));
+        fields.headers = Schema2.optionalKey(reflectedSchema2(endpoint.headers));
       }
-      const payloadSchemas = Array.from(endpoint.payload.values()).flatMap(({ schemas: schemas2 }) => schemas2.map(reflectedSchema));
+      const payloadSchemas = Array.from(endpoint.payload.values()).flatMap(({ schemas: schemas2 }) => schemas2.map(reflectedSchema2));
       if (payloadSchemas.length === 1 && payloadSchemas[0]) {
         fields.body = payloadSchemas[0];
       } else if (payloadSchemas.length > 1) {
@@ -301,7 +342,7 @@ class HttpApiSpec extends Context2.Service()("HttpApiSpec", {
       if (!HttpApi2.isHttpApi(api)) {
         throw new Error("HttpApiSpec requires a valid HttpApi");
       }
-      const spec = OpenApi.fromApi(api);
+      const spec = OpenApi2.fromApi(api);
       const reflectedSchemas = reflectedOperationInputSchemas(api);
       const operations = httpApiOperations({
         spec,

package/dist/lib/httpapi-toolkit.js

@@ -3,13 +3,22 @@ import { Effect as Effect3, Layer as Layer3, Schema as Schema3 } from "effect";
 import { Tool, Toolkit } from "effect/unstable/ai";
 
 // ../../src/lib/httpapi-client.ts
-import { Context, Effect, Layer, Schema } from "effect";
+import { Context, Effect, Layer, Schema, SchemaTransformation } from "effect";
 import { HttpClient } from "effect/unstable/http";
 import {
-  HttpApiClient as EffectHttpApiClient
+  HttpApi,
+  HttpApiClient as EffectHttpApiClient,
+  OpenApi
 } from "effect/unstable/httpapi";
+var UndefinedFromNull = Schema.Null.pipe(Schema.decodeTo(Schema.Undefined, SchemaTransformation.transform({
+  decode: () => {
+    return;
+  },
+  encode: () => null
+})));
 var HttpApiOperationResultValue = Schema.suspend(() => Schema.Union([
   Schema.Null,
+  UndefinedFromNull,
   Schema.String,
   Schema.Number,
   Schema.Boolean,
@@ -23,6 +32,37 @@ var HttpApiOperationResult = Schema.Union([
   Schema.Undefined
 ]).annotate({ identifier: "HttpApiOperationResult" });
 var encodeHttpApiOperationResult = Effect.fn("HttpApiClient.encodeOperationResult")((result) => Schema.encodeUnknownEffect(HttpApiOperationResult)(result).pipe(Effect.map((encoded) => encoded ?? null), Effect.mapError((cause) => new Error("HTTP API result is not serializable", { cause }))));
+var reflectedSchema = (schema) => Schema.make(schema.ast);
+var operationResultSchemas = (api) => {
+  const schemas = new Map;
+  HttpApi.reflect(api, {
+    onGroup: () => {
+      return;
+    },
+    onEndpoint: ({ endpoint, group, successes }) => {
+      const operationId = Context.getOrElse(endpoint.annotations, OpenApi.Identifier, () => group.topLevel ? endpoint.identifier : `${group.identifier}.${endpoint.identifier}`);
+      const operationSchemas = Array.from(successes.values()).flat().map(reflectedSchema);
+      if (operationSchemas.length === 1 && operationSchemas[0]) {
+        schemas.set(operationId, operationSchemas[0]);
+      } else if (operationSchemas.length > 1) {
+        schemas.set(operationId, Schema.Union(operationSchemas));
+      }
+    }
+  });
+  return schemas;
+};
+var makeHttpApiOperationResultEncoder = (api) => {
+  const schemas = operationResultSchemas(api);
+  return Effect.fn("HttpApiClient.encodeOperationResultWithSchema")((result, operation) => {
+    const operationId = operation.operation.operationId;
+    const schema = operationId ? schemas.get(operationId) : undefined;
+    if (!schema)
+      return encodeHttpApiOperationResult(result);
+    return Schema.encodeUnknownEffect(schema)(result).pipe(Effect.flatMap(encodeHttpApiOperationResult), Effect.mapError((cause) => new Error("HTTP API result does not match its success schema", {
+      cause
+    })));
+  });
+};
 var GeneratedOperation = Schema.declare((value) => value instanceof Function).annotate({ identifier: "GeneratedOperation" });
 var GeneratedOperationEffect = Schema.declare((value) => Effect.isEffect(value)).annotate({ identifier: "GeneratedOperationEffect" });
 var makeGeneratedClient = (api, http, baseUrl) => EffectHttpApiClient.makeWith(api, {
@@ -58,9 +98,10 @@ var executeGeneratedOperation = Effect.fn("HttpApiClient.executeGeneratedOperati
 class ApiClient extends Context.Service()("ApiClient") {
   static layer = (config) => Layer.effect(this, Effect.gen(function* () {
     const http = yield* HttpClient.HttpClient;
+    const encodeResult = makeHttpApiOperationResultEncoder(config.api);
     const client = yield* makeGeneratedClient(config.api, http, config.baseUrl);
     return {
-      encodeResult: config.encodeResult ?? ((result) => encodeHttpApiOperationResult(result)),
+      encodeResult: config.encodeResult ?? ((result, operation) => encodeResult(result, operation)),
       execute: Effect.fn("ApiClient.execute")(function* (options) {
         return yield* executeGeneratedOperation(client, options);
       })
@@ -78,7 +119,7 @@ import {
   Schema as Schema2,
   SchemaRepresentation
 } from "effect";
-import { HttpApi as HttpApi2, OpenApi } from "effect/unstable/httpapi";
+import { HttpApi as HttpApi2, OpenApi as OpenApi2 } from "effect/unstable/httpapi";
 var JsonObjectSchema = Schema2.Record(Schema2.String, Schema2.Json).annotate({
   identifier: "HttpJsonObject",
   title: "HTTP JSON object",
@@ -251,7 +292,7 @@ var decodeHttpApiOperationInput = Effect2.fn("Http.decodeApiOperationInput")(fun
     query: pickParameters("query")
   };
 });
-var reflectedSchema = (schema) => Schema2.make(schema.ast);
+var reflectedSchema2 = (schema) => Schema2.make(schema.ast);
 var reflectedOperationInputSchemas = (api) => {
   const schemas = new Map;
   HttpApi2.reflect(api, {
@@ -259,17 +300,17 @@ var reflectedOperationInputSchemas = (api) => {
       return;
     },
     onEndpoint: ({ endpoint, group }) => {
-      const operationId = Context2.getOrElse(endpoint.annotations, OpenApi.Identifier, () => group.topLevel ? endpoint.identifier : `${group.identifier}.${endpoint.identifier}`);
+      const operationId = Context2.getOrElse(endpoint.annotations, OpenApi2.Identifier, () => group.topLevel ? endpoint.identifier : `${group.identifier}.${endpoint.identifier}`);
       const fields = {};
       if (endpoint.params)
-        fields.params = reflectedSchema(endpoint.params);
+        fields.params = reflectedSchema2(endpoint.params);
       if (endpoint.query) {
-        fields.query = Schema2.optionalKey(reflectedSchema(endpoint.query));
+        fields.query = Schema2.optionalKey(reflectedSchema2(endpoint.query));
       }
       if (endpoint.headers) {
-        fields.headers = Schema2.optionalKey(reflectedSchema(endpoint.headers));
+        fields.headers = Schema2.optionalKey(reflectedSchema2(endpoint.headers));
       }
-      const payloadSchemas = Array.from(endpoint.payload.values()).flatMap(({ schemas: schemas2 }) => schemas2.map(reflectedSchema));
+      const payloadSchemas = Array.from(endpoint.payload.values()).flatMap(({ schemas: schemas2 }) => schemas2.map(reflectedSchema2));
       if (payloadSchemas.length === 1 && payloadSchemas[0]) {
         fields.body = payloadSchemas[0];
       } else if (payloadSchemas.length > 1) {
@@ -301,7 +342,7 @@ class HttpApiSpec extends Context2.Service()("HttpApiSpec", {
       if (!HttpApi2.isHttpApi(api)) {
         throw new Error("HttpApiSpec requires a valid HttpApi");
       }
-      const spec = OpenApi.fromApi(api);
+      const spec = OpenApi2.fromApi(api);
       const reflectedSchemas = reflectedOperationInputSchemas(api);
       const operations = httpApiOperations({
         spec,

package/dist/services/health/api.builder.d.ts

@@ -0,0 +1,66 @@
+import { HttpRouter } from "effect/unstable/http";
+import { HttpApiBuilder, HttpApiGroup } from "effect/unstable/httpapi";
+import { HealthApiGroup } from "./api.group.js";
+import { HealthService } from "./index.js";
+export declare const healthHandler: <const Prefix extends HttpRouter.PathInput>(handlers: HttpApiBuilder.Handlers.FromGroup<HttpApiGroup.AddPrefix<typeof HealthApiGroup, Prefix>>) => HttpApiBuilder.Handlers<HttpRouter.Request<"Requires", HealthService>, {
+    readonly getHealth: import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"getHealth", "GET", `${Prefix}/health`, never, never, never, never, import("effect/Schema").toCodecJson<import("effect/Schema").Struct<{
+        readonly status: import("effect/Schema").Literal<"UP">;
+        readonly checks: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly name: import("effect/Schema").NonEmptyString;
+            readonly status: import("effect/Schema").Literals<readonly ["UP", "DOWN"]>;
+            readonly data: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").Boolean, import("effect/Schema").Number]>>>;
+        }>>;
+    }>>, import("effect/Schema").toCodecJson<import("effect/Schema").Struct<{
+        readonly status: import("effect/Schema").Literal<"DOWN">;
+        readonly checks: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly name: import("effect/Schema").NonEmptyString;
+            readonly status: import("effect/Schema").Literals<readonly ["UP", "DOWN"]>;
+            readonly data: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").Boolean, import("effect/Schema").Number]>>>;
+        }>>;
+    }> | typeof import("effect/unstable/httpapi/HttpApiError").InternalServerError>, never, never>;
+    readonly getLiveness: import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"getLiveness", "GET", `${Prefix}/health/live`, never, never, never, never, import("effect/Schema").toCodecJson<import("effect/Schema").Struct<{
+        readonly status: import("effect/Schema").Literal<"UP">;
+        readonly checks: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly name: import("effect/Schema").NonEmptyString;
+            readonly status: import("effect/Schema").Literals<readonly ["UP", "DOWN"]>;
+            readonly data: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").Boolean, import("effect/Schema").Number]>>>;
+        }>>;
+    }>>, import("effect/Schema").toCodecJson<import("effect/Schema").Struct<{
+        readonly status: import("effect/Schema").Literal<"DOWN">;
+        readonly checks: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly name: import("effect/Schema").NonEmptyString;
+            readonly status: import("effect/Schema").Literals<readonly ["UP", "DOWN"]>;
+            readonly data: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").Boolean, import("effect/Schema").Number]>>>;
+        }>>;
+    }> | typeof import("effect/unstable/httpapi/HttpApiError").InternalServerError>, never, never>;
+    readonly getReadiness: import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"getReadiness", "GET", `${Prefix}/health/ready`, never, never, never, never, import("effect/Schema").toCodecJson<import("effect/Schema").Struct<{
+        readonly status: import("effect/Schema").Literal<"UP">;
+        readonly checks: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly name: import("effect/Schema").NonEmptyString;
+            readonly status: import("effect/Schema").Literals<readonly ["UP", "DOWN"]>;
+            readonly data: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").Boolean, import("effect/Schema").Number]>>>;
+        }>>;
+    }>>, import("effect/Schema").toCodecJson<import("effect/Schema").Struct<{
+        readonly status: import("effect/Schema").Literal<"DOWN">;
+        readonly checks: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly name: import("effect/Schema").NonEmptyString;
+            readonly status: import("effect/Schema").Literals<readonly ["UP", "DOWN"]>;
+            readonly data: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").Boolean, import("effect/Schema").Number]>>>;
+        }>>;
+    }> | typeof import("effect/unstable/httpapi/HttpApiError").InternalServerError>, never, never>;
+    readonly getStartup: import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"getStartup", "GET", `${Prefix}/health/started`, never, never, never, never, import("effect/Schema").toCodecJson<import("effect/Schema").Struct<{
+        readonly status: import("effect/Schema").Literal<"UP">;
+        readonly checks: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly name: import("effect/Schema").NonEmptyString;
+            readonly status: import("effect/Schema").Literals<readonly ["UP", "DOWN"]>;
+            readonly data: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").Boolean, import("effect/Schema").Number]>>>;
+        }>>;
+    }>>, import("effect/Schema").toCodecJson<import("effect/Schema").Struct<{
+        readonly status: import("effect/Schema").Literal<"DOWN">;
+        readonly checks: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly name: import("effect/Schema").NonEmptyString;
+            readonly status: import("effect/Schema").Literals<readonly ["UP", "DOWN"]>;
+            readonly data: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").Boolean, import("effect/Schema").Number]>>>;
+        }>>;
+    }> | typeof import("effect/unstable/httpapi/HttpApiError").InternalServerError>, never, never>;
+}, "getHealth" | "getLiveness" | "getReadiness" | "getStartup">;

package/dist/services/health/api.group.d.ts

@@ -0,0 +1,58 @@
+import { HttpApiEndpoint, HttpApiError, HttpApiGroup } from "effect/unstable/httpapi";
+export declare const HealthApiGroup: HttpApiGroup.HttpApiGroup<"health", HttpApiEndpoint.HttpApiEndpoint<"getHealth", "GET", "/health", never, never, never, never, import("effect/Schema").toCodecJson<import("effect/Schema").Struct<{
+    readonly status: import("effect/Schema").Literal<"UP">;
+    readonly checks: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        readonly name: import("effect/Schema").NonEmptyString;
+        readonly status: import("effect/Schema").Literals<readonly ["UP", "DOWN"]>;
+        readonly data: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").Boolean, import("effect/Schema").Number]>>>;
+    }>>;
+}>>, import("effect/Schema").toCodecJson<import("effect/Schema").Struct<{
+    readonly status: import("effect/Schema").Literal<"DOWN">;
+    readonly checks: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        readonly name: import("effect/Schema").NonEmptyString;
+        readonly status: import("effect/Schema").Literals<readonly ["UP", "DOWN"]>;
+        readonly data: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").Boolean, import("effect/Schema").Number]>>>;
+    }>>;
+}> | typeof HttpApiError.InternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"getLiveness", "GET", "/health/live", never, never, never, never, import("effect/Schema").toCodecJson<import("effect/Schema").Struct<{
+    readonly status: import("effect/Schema").Literal<"UP">;
+    readonly checks: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        readonly name: import("effect/Schema").NonEmptyString;
+        readonly status: import("effect/Schema").Literals<readonly ["UP", "DOWN"]>;
+        readonly data: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").Boolean, import("effect/Schema").Number]>>>;
+    }>>;
+}>>, import("effect/Schema").toCodecJson<import("effect/Schema").Struct<{
+    readonly status: import("effect/Schema").Literal<"DOWN">;
+    readonly checks: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        readonly name: import("effect/Schema").NonEmptyString;
+        readonly status: import("effect/Schema").Literals<readonly ["UP", "DOWN"]>;
+        readonly data: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").Boolean, import("effect/Schema").Number]>>>;
+    }>>;
+}> | typeof HttpApiError.InternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"getReadiness", "GET", "/health/ready", never, never, never, never, import("effect/Schema").toCodecJson<import("effect/Schema").Struct<{
+    readonly status: import("effect/Schema").Literal<"UP">;
+    readonly checks: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        readonly name: import("effect/Schema").NonEmptyString;
+        readonly status: import("effect/Schema").Literals<readonly ["UP", "DOWN"]>;
+        readonly data: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").Boolean, import("effect/Schema").Number]>>>;
+    }>>;
+}>>, import("effect/Schema").toCodecJson<import("effect/Schema").Struct<{
+    readonly status: import("effect/Schema").Literal<"DOWN">;
+    readonly checks: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        readonly name: import("effect/Schema").NonEmptyString;
+        readonly status: import("effect/Schema").Literals<readonly ["UP", "DOWN"]>;
+        readonly data: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").Boolean, import("effect/Schema").Number]>>>;
+    }>>;
+}> | typeof HttpApiError.InternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"getStartup", "GET", "/health/started", never, never, never, never, import("effect/Schema").toCodecJson<import("effect/Schema").Struct<{
+    readonly status: import("effect/Schema").Literal<"UP">;
+    readonly checks: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        readonly name: import("effect/Schema").NonEmptyString;
+        readonly status: import("effect/Schema").Literals<readonly ["UP", "DOWN"]>;
+        readonly data: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").Boolean, import("effect/Schema").Number]>>>;
+    }>>;
+}>>, import("effect/Schema").toCodecJson<import("effect/Schema").Struct<{
+    readonly status: import("effect/Schema").Literal<"DOWN">;
+    readonly checks: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        readonly name: import("effect/Schema").NonEmptyString;
+        readonly status: import("effect/Schema").Literals<readonly ["UP", "DOWN"]>;
+        readonly data: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").Boolean, import("effect/Schema").Number]>>>;
+    }>>;
+}> | typeof HttpApiError.InternalServerError>, never, never>, false>;

package/dist/services/health/index.d.ts

@@ -0,0 +1,253 @@
+import { Context, Effect, Layer } from "effect";
+import type { HealthCheckData, HealthCheckOutcome } from "./schema.js";
+export type HealthCheck<Requirements = never> = {
+    readonly name: string;
+    readonly check: Effect.Effect<HealthCheckOutcome, unknown, Requirements>;
+};
+export type HealthServiceChecks<Requirements = never> = {
+    readonly live?: ReadonlyArray<HealthCheck<Requirements>>;
+    readonly ready?: ReadonlyArray<HealthCheck<Requirements>>;
+    readonly started?: ReadonlyArray<HealthCheck<Requirements>>;
+};
+export type HealthServiceOptions<Requirements = never> = {
+    readonly checks?: HealthServiceChecks<Requirements>;
+};
+type RegisteredHealthChecks = {
+    readonly live: ReadonlyArray<HealthCheck>;
+    readonly ready: ReadonlyArray<HealthCheck>;
+    readonly started: ReadonlyArray<HealthCheck>;
+};
+declare const HealthServiceConfig_base: Context.ServiceClass<HealthServiceConfig, "@krak-stack/registry/HealthServiceConfig", RegisteredHealthChecks>;
+declare class HealthServiceConfig extends HealthServiceConfig_base {
+    static readonly layerWith: <Requirements = never>({ checks, }?: HealthServiceOptions<Requirements>) => Layer.Layer<HealthServiceConfig, never, Exclude<Requirements, import("effect/Scope").Scope>>;
+}
+declare const HealthService_base: Context.ServiceClass<HealthService, "@krak-stack/registry/HealthService", {
+    aggregate: () => Effect.Effect<{
+        status: "UP";
+        checks: ({
+            name: string;
+            status: "DOWN" | "UP";
+            data?: undefined;
+        } | {
+            name: string;
+            status: "DOWN" | "UP";
+            data: {
+                readonly [x: string]: string | number | boolean;
+            };
+        })[];
+    } | {
+        status: "DOWN";
+        checks: ({
+            name: string;
+            status: "DOWN" | "UP";
+            data?: undefined;
+        } | {
+            name: string;
+            status: "DOWN" | "UP";
+            data: {
+                readonly [x: string]: string | number | boolean;
+            };
+        })[];
+    }, never, never>;
+    live: () => Effect.Effect<{
+        status: "UP";
+        checks: ({
+            name: string;
+            status: "DOWN" | "UP";
+            data?: undefined;
+        } | {
+            name: string;
+            status: "DOWN" | "UP";
+            data: {
+                readonly [x: string]: string | number | boolean;
+            };
+        })[];
+    } | {
+        status: "DOWN";
+        checks: ({
+            name: string;
+            status: "DOWN" | "UP";
+            data?: undefined;
+        } | {
+            name: string;
+            status: "DOWN" | "UP";
+            data: {
+                readonly [x: string]: string | number | boolean;
+            };
+        })[];
+    }, never, never>;
+    ready: () => Effect.Effect<{
+        status: "UP";
+        checks: ({
+            name: string;
+            status: "DOWN" | "UP";
+            data?: undefined;
+        } | {
+            name: string;
+            status: "DOWN" | "UP";
+            data: {
+                readonly [x: string]: string | number | boolean;
+            };
+        })[];
+    } | {
+        status: "DOWN";
+        checks: ({
+            name: string;
+            status: "DOWN" | "UP";
+            data?: undefined;
+        } | {
+            name: string;
+            status: "DOWN" | "UP";
+            data: {
+                readonly [x: string]: string | number | boolean;
+            };
+        })[];
+    }, never, never>;
+    started: () => Effect.Effect<{
+        status: "UP";
+        checks: ({
+            name: string;
+            status: "DOWN" | "UP";
+            data?: undefined;
+        } | {
+            name: string;
+            status: "DOWN" | "UP";
+            data: {
+                readonly [x: string]: string | number | boolean;
+            };
+        })[];
+    } | {
+        status: "DOWN";
+        checks: ({
+            name: string;
+            status: "DOWN" | "UP";
+            data?: undefined;
+        } | {
+            name: string;
+            status: "DOWN" | "UP";
+            data: {
+                readonly [x: string]: string | number | boolean;
+            };
+        })[];
+    }, never, never>;
+}> & {
+    readonly make: Effect.Effect<{
+        aggregate: () => Effect.Effect<{
+            status: "UP";
+            checks: ({
+                name: string;
+                status: "DOWN" | "UP";
+                data?: undefined;
+            } | {
+                name: string;
+                status: "DOWN" | "UP";
+                data: {
+                    readonly [x: string]: string | number | boolean;
+                };
+            })[];
+        } | {
+            status: "DOWN";
+            checks: ({
+                name: string;
+                status: "DOWN" | "UP";
+                data?: undefined;
+            } | {
+                name: string;
+                status: "DOWN" | "UP";
+                data: {
+                    readonly [x: string]: string | number | boolean;
+                };
+            })[];
+        }, never, never>;
+        live: () => Effect.Effect<{
+            status: "UP";
+            checks: ({
+                name: string;
+                status: "DOWN" | "UP";
+                data?: undefined;
+            } | {
+                name: string;
+                status: "DOWN" | "UP";
+                data: {
+                    readonly [x: string]: string | number | boolean;
+                };
+            })[];
+        } | {
+            status: "DOWN";
+            checks: ({
+                name: string;
+                status: "DOWN" | "UP";
+                data?: undefined;
+            } | {
+                name: string;
+                status: "DOWN" | "UP";
+                data: {
+                    readonly [x: string]: string | number | boolean;
+                };
+            })[];
+        }, never, never>;
+        ready: () => Effect.Effect<{
+            status: "UP";
+            checks: ({
+                name: string;
+                status: "DOWN" | "UP";
+                data?: undefined;
+            } | {
+                name: string;
+                status: "DOWN" | "UP";
+                data: {
+                    readonly [x: string]: string | number | boolean;
+                };
+            })[];
+        } | {
+            status: "DOWN";
+            checks: ({
+                name: string;
+                status: "DOWN" | "UP";
+                data?: undefined;
+            } | {
+                name: string;
+                status: "DOWN" | "UP";
+                data: {
+                    readonly [x: string]: string | number | boolean;
+                };
+            })[];
+        }, never, never>;
+        started: () => Effect.Effect<{
+            status: "UP";
+            checks: ({
+                name: string;
+                status: "DOWN" | "UP";
+                data?: undefined;
+            } | {
+                name: string;
+                status: "DOWN" | "UP";
+                data: {
+                    readonly [x: string]: string | number | boolean;
+                };
+            })[];
+        } | {
+            status: "DOWN";
+            checks: ({
+                name: string;
+                status: "DOWN" | "UP";
+                data?: undefined;
+            } | {
+                name: string;
+                status: "DOWN" | "UP";
+                data: {
+                    readonly [x: string]: string | number | boolean;
+                };
+            })[];
+        }, never, never>;
+    }, never, HealthServiceConfig>;
+};
+export declare class HealthService extends HealthService_base {
+    static readonly up: (data?: HealthCheckData) => HealthCheckOutcome;
+    static readonly down: (data?: HealthCheckData) => HealthCheckOutcome;
+    static readonly layer: Layer.Layer<HealthService, never, never>;
+    static readonly layerWith: <Requirements = never>(options: HealthServiceOptions<Requirements>) => Layer.Layer<HealthService, never, Exclude<Requirements, import("effect/Scope").Scope>>;
+}
+export * from "./api.builder.js";
+export * from "./api.group.js";
+export * from "./schema.js";

package/dist/services/health/index.js

@@ -0,0 +1,186 @@
+// ../../src/services/health/index.ts
+import { Context, Effect as Effect2, Exit, Layer } from "effect";
+
+// ../../src/services/health/api.builder.ts
+import { Effect } from "effect";
+var respond = (check) => check.pipe(Effect.flatMap((response) => response.status === "UP" ? Effect.succeed(response) : Effect.fail(response)));
+var healthHandler = (handlers) => handlers.handle("getHealth", () => Effect.flatMap(HealthService, ({ aggregate }) => respond(aggregate()))).handle("getLiveness", () => Effect.flatMap(HealthService, ({ live }) => respond(live()))).handle("getReadiness", () => Effect.flatMap(HealthService, ({ ready }) => respond(ready()))).handle("getStartup", () => Effect.flatMap(HealthService, ({ started }) => respond(started())));
+// ../../src/services/health/api.group.ts
+import {
+  HttpApiEndpoint,
+  HttpApiError,
+  HttpApiGroup,
+  OpenApi
+} from "effect/unstable/httpapi";
+
+// ../../src/services/health/schema.ts
+import { Schema } from "effect";
+import { HttpApiSchema } from "effect/unstable/httpapi";
+var HealthStatus = Schema.Literals(["UP", "DOWN"]).annotate({
+  identifier: "HealthStatus",
+  title: "Health Status",
+  description: "Whether a health check is up or down"
+});
+var HealthCheckData = Schema.Record(Schema.String, Schema.Union([Schema.String, Schema.Boolean, Schema.Number])).annotate({
+  identifier: "HealthCheckData",
+  title: "Health Check Data",
+  description: "Non-sensitive diagnostic values for a health check"
+});
+var HealthCheckOutcome = Schema.Struct({
+  status: HealthStatus,
+  data: Schema.optionalKey(HealthCheckData)
+}).annotate({
+  identifier: "HealthCheckOutcome",
+  title: "Health Check Outcome",
+  description: "The status and optional diagnostic data returned by a check"
+});
+var HealthCheckResult = Schema.Struct({
+  name: Schema.NonEmptyString,
+  status: HealthStatus,
+  data: Schema.optionalKey(HealthCheckData)
+}).annotate({
+  identifier: "HealthCheckResult",
+  title: "Health Check Result",
+  description: "The outcome of a named health check"
+});
+var HealthUpResponse = Schema.Struct({
+  status: Schema.Literal("UP"),
+  checks: Schema.Array(HealthCheckResult)
+}).annotate({
+  identifier: "HealthUpResponse",
+  title: "Healthy Response",
+  description: "A response where all health checks are up",
+  examples: [{ status: "UP", checks: [] }]
+});
+var HealthDownResponse = Schema.Struct({
+  status: Schema.Literal("DOWN"),
+  checks: Schema.Array(HealthCheckResult)
+}).pipe(HttpApiSchema.status(503)).annotate({
+  identifier: "HealthDownResponse",
+  title: "Unhealthy Response",
+  description: "A response where one or more health checks are down",
+  examples: [
+    {
+      status: "DOWN",
+      checks: [{ name: "database", status: "DOWN" }]
+    }
+  ]
+});
+var HealthResponse = Schema.Union([
+  HealthUpResponse,
+  HealthDownResponse
+]).annotate({
+  identifier: "HealthResponse",
+  title: "Health Response",
+  description: "An aggregate health response"
+});
+
+// ../../src/services/health/api.group.ts
+var errors = [HealthDownResponse, HttpApiError.InternalServerError];
+var HealthApiGroup = HttpApiGroup.make("health").annotateMerge(OpenApi.annotations({
+  title: "Health",
+  description: "Application health checks"
+})).add(HttpApiEndpoint.get("getHealth", "/health", {
+  success: HealthUpResponse,
+  error: errors
+}).annotateMerge(OpenApi.annotations({
+  summary: "Get aggregate health",
+  description: "Runs all registered liveness, readiness, and startup checks."
+}))).add(HttpApiEndpoint.get("getLiveness", "/health/live", {
+  success: HealthUpResponse,
+  error: errors
+}).annotateMerge(OpenApi.annotations({
+  summary: "Get application liveness",
+  description: "Returns whether the application process is responsive."
+}))).add(HttpApiEndpoint.get("getReadiness", "/health/ready", {
+  success: HealthUpResponse,
+  error: errors
+}).annotateMerge(OpenApi.annotations({
+  summary: "Get application readiness",
+  description: "Returns whether the application is ready to serve traffic."
+}))).add(HttpApiEndpoint.get("getStartup", "/health/started", {
+  success: HealthUpResponse,
+  error: errors
+}).annotateMerge(OpenApi.annotations({
+  summary: "Get application startup status",
+  description: "Returns whether the application has completed startup."
+})));
+
+// ../../src/services/health/index.ts
+class HealthServiceConfig extends Context.Service()("@krak-stack/registry/HealthServiceConfig") {
+  static layerWith = ({
+    checks = {}
+  } = {}) => Layer.effect(this, Effect2.gen(function* () {
+    const services = yield* Effect2.context();
+    const resolve = (registered) => (registered ?? []).map(({ name, check }) => ({
+      name,
+      check: Effect2.provide(check, services)
+    }));
+    return {
+      live: resolve(checks.live),
+      ready: resolve(checks.ready),
+      started: resolve(checks.started)
+    };
+  }));
+}
+
+class HealthService extends Context.Service()("@krak-stack/registry/HealthService", {
+  make: Effect2.gen(function* () {
+    const checks = yield* HealthServiceConfig;
+    const allChecks = Array.from(new Set([...checks.live, ...checks.ready, ...checks.started]));
+    const execute = Effect2.fn("HealthService.execute")(function* (healthCheck) {
+      const exit = yield* Effect2.exit(healthCheck.check);
+      if (!Exit.isSuccess(exit)) {
+        return {
+          name: healthCheck.name,
+          status: "DOWN"
+        };
+      }
+      return exit.value.data === undefined ? {
+        name: healthCheck.name,
+        status: exit.value.status
+      } : {
+        name: healthCheck.name,
+        status: exit.value.status,
+        data: exit.value.data
+      };
+    });
+    const run = Effect2.fn("HealthService.run")(function* (registered) {
+      const results = yield* Effect2.forEach(registered, execute, {
+        concurrency: "unbounded"
+      });
+      if (results.every(({ status }) => status === "UP")) {
+        return {
+          status: "UP",
+          checks: results
+        };
+      }
+      return {
+        status: "DOWN",
+        checks: results
+      };
+    });
+    const aggregate = Effect2.fn("HealthService.aggregate")(() => run(allChecks));
+    const live = Effect2.fn("HealthService.live")(() => run(checks.live));
+    const ready = Effect2.fn("HealthService.ready")(() => run(checks.ready));
+    const started = Effect2.fn("HealthService.started")(() => run(checks.started));
+    return { aggregate, live, ready, started };
+  })
+}) {
+  static up = (data) => data === undefined ? { status: "UP" } : { status: "UP", data };
+  static down = (data) => data === undefined ? { status: "DOWN" } : { status: "DOWN", data };
+  static layer = Layer.effect(this, this.make).pipe(Layer.provide(HealthServiceConfig.layerWith()));
+  static layerWith = (options) => Layer.effect(this, this.make).pipe(Layer.provide(HealthServiceConfig.layerWith(options)));
+}
+export {
+  healthHandler,
+  HealthUpResponse,
+  HealthStatus,
+  HealthService,
+  HealthResponse,
+  HealthDownResponse,
+  HealthCheckResult,
+  HealthCheckOutcome,
+  HealthCheckData,
+  HealthApiGroup
+};

package/dist/services/health/schema.d.ts

@@ -0,0 +1,50 @@
+import { Schema } from "effect";
+export declare const HealthStatus: Schema.Literals<readonly ["UP", "DOWN"]>;
+export type HealthStatus = typeof HealthStatus.Type;
+export declare const HealthCheckData: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Boolean, Schema.Number]>>;
+export type HealthCheckData = typeof HealthCheckData.Type;
+export declare const HealthCheckOutcome: Schema.Struct<{
+    readonly status: Schema.Literals<readonly ["UP", "DOWN"]>;
+    readonly data: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Boolean, Schema.Number]>>>;
+}>;
+export type HealthCheckOutcome = typeof HealthCheckOutcome.Type;
+export declare const HealthCheckResult: Schema.Struct<{
+    readonly name: Schema.NonEmptyString;
+    readonly status: Schema.Literals<readonly ["UP", "DOWN"]>;
+    readonly data: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Boolean, Schema.Number]>>>;
+}>;
+export type HealthCheckResult = typeof HealthCheckResult.Type;
+export declare const HealthUpResponse: Schema.Struct<{
+    readonly status: Schema.Literal<"UP">;
+    readonly checks: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.NonEmptyString;
+        readonly status: Schema.Literals<readonly ["UP", "DOWN"]>;
+        readonly data: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Boolean, Schema.Number]>>>;
+    }>>;
+}>;
+export type HealthUpResponse = typeof HealthUpResponse.Type;
+export declare const HealthDownResponse: Schema.Struct<{
+    readonly status: Schema.Literal<"DOWN">;
+    readonly checks: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.NonEmptyString;
+        readonly status: Schema.Literals<readonly ["UP", "DOWN"]>;
+        readonly data: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Boolean, Schema.Number]>>>;
+    }>>;
+}>;
+export type HealthDownResponse = typeof HealthDownResponse.Type;
+export declare const HealthResponse: Schema.Union<readonly [Schema.Struct<{
+    readonly status: Schema.Literal<"UP">;
+    readonly checks: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.NonEmptyString;
+        readonly status: Schema.Literals<readonly ["UP", "DOWN"]>;
+        readonly data: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Boolean, Schema.Number]>>>;
+    }>>;
+}>, Schema.Struct<{
+    readonly status: Schema.Literal<"DOWN">;
+    readonly checks: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.NonEmptyString;
+        readonly status: Schema.Literals<readonly ["UP", "DOWN"]>;
+        readonly data: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Boolean, Schema.Number]>>>;
+    }>>;
+}>]>;
+export type HealthResponse = typeof HealthResponse.Type;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@krak-stack/registry",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "description": "Tree-shakable KrakStack components and Effect services.",
   "license": "MIT",
   "repository": {
@@ -199,6 +199,10 @@
       "types": "./dist/services/file-extraction/schema.d.ts",
       "import": "./dist/services/file-extraction/schema.js"
     },
+    "./service-health": {
+      "types": "./dist/services/health/index.d.ts",
+      "import": "./dist/services/health/index.js"
+    },
     "./tailwind.css": "./tailwind.css",
     "./package.json": "./package.json"
   },