@krak-stack/registry 0.1.18 → 0.1.20

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

@@ -20,6 +20,14 @@ declare const AgentService_base: Context.ServiceClass<AgentService, "AgentServic
         readonly type: Schema.Literal<"text-delta">;
         readonly messageId: Schema.String;
         readonly delta: Schema.String;
+    }, "Type"> | Schema.Struct.ReadonlySide<{
+        readonly type: Schema.Literal<"markdown-snapshot">;
+        readonly messageId: Schema.String;
+        readonly html: Schema.String;
+        readonly codeBlocks: Schema.$Array<Schema.Struct<{
+            readonly code: Schema.String;
+            readonly language: Schema.String;
+        }>>;
     }, "Type"> | Schema.Struct.ReadonlySide<{
         readonly type: Schema.Literal<"tool-call">;
         readonly messageId: Schema.String;
@@ -66,6 +74,14 @@ declare const AgentService_base: Context.ServiceClass<AgentService, "AgentServic
             readonly type: Schema.Literal<"text-delta">;
             readonly messageId: Schema.String;
             readonly delta: Schema.String;
+        }, "Type"> | Schema.Struct.ReadonlySide<{
+            readonly type: Schema.Literal<"markdown-snapshot">;
+            readonly messageId: Schema.String;
+            readonly html: Schema.String;
+            readonly codeBlocks: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.String;
+                readonly language: Schema.String;
+            }>>;
         }, "Type"> | Schema.Struct.ReadonlySide<{
             readonly type: Schema.Literal<"tool-call">;
             readonly messageId: Schema.String;

package/dist/services/agent/index.js

@@ -16,6 +16,76 @@ import {
   Tool
 } from "effect/unstable/ai";
 
+// ../../src/lib/markdown/server.ts
+var escapeHtml = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("'", "&#39;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+var decodeMarkdownCode = (value) => value.replaceAll("&quot;", '"').replaceAll("&#39;", "'").replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&amp;", "&");
+var safeUrl = (value, image = false) => {
+  if (value.startsWith("/") || value.startsWith("#") || value.startsWith("https://") || value.startsWith("http://") || !image && value.startsWith("mailto:")) {
+    return value;
+  }
+  return image ? "" : "#";
+};
+var markdownOptions = {
+  autolinks: true,
+  headings: { ids: true },
+  noHtmlBlocks: true,
+  noHtmlSpans: true,
+  tagFilter: true
+};
+var compileMarkdown = (source) => {
+  const codeBlocks = [];
+  const html = Bun.markdown.render(source, {
+    blockquote: (children) => `<blockquote>${children}</blockquote>`,
+    code: (children, meta) => {
+      const index = codeBlocks.length;
+      const code = decodeMarkdownCode(children.replace(/\n$/, ""));
+      const language = meta?.language ?? "text";
+      codeBlocks.push({ code, language });
+      return `<markdown-code-block data-index="${index}"></markdown-code-block>`;
+    },
+    codespan: (children) => `<code data-inline-code>${escapeHtml(children)}</code>`,
+    emphasis: (children) => `<em>${children}</em>`,
+    heading: (children, { id, level }) => {
+      const headingId = escapeHtml(id ?? "");
+      const anchor = level === 2 || level === 3 ? `<a href="#${headingId}" aria-hidden="true">#</a>` : "";
+      return `<h${level} id="${headingId}">${children}${anchor}</h${level}>`;
+    },
+    hr: () => "<hr>",
+    html: (children) => escapeHtml(children),
+    image: (children, { src, title }) => {
+      const resolvedSrc = safeUrl(src, true);
+      if (!resolvedSrc)
+        return children;
+      const titleAttribute = title ? ` title="${escapeHtml(title)}"` : "";
+      return `<img src="${escapeHtml(resolvedSrc)}" alt="${escapeHtml(children)}"${titleAttribute}>`;
+    },
+    link: (children, { href, title }) => {
+      const resolvedHref = safeUrl(href);
+      const external = /^https?:\/\//.test(resolvedHref);
+      const titleAttribute = title ? ` title="${escapeHtml(title)}"` : "";
+      const externalAttributes = external ? ' target="_blank" rel="noreferrer"' : "";
+      return `<a href="${escapeHtml(resolvedHref)}"${titleAttribute}${externalAttributes}>${children}</a>`;
+    },
+    list: (children, { ordered, start }) => ordered ? `<ol${start && start !== 1 ? ` start="${start}"` : ""}>${children}</ol>` : `<ul>${children}</ul>`,
+    listItem: (children, { checked }) => {
+      const checkbox = checked === undefined ? "" : `<input type="checkbox" disabled${checked ? " checked" : ""}>`;
+      return `<li>${checkbox}${children}</li>`;
+    },
+    paragraph: (children) => `<p>${children}</p>`,
+    strikethrough: (children) => `<del>${children}</del>`,
+    strong: (children) => `<strong>${children}</strong>`,
+    table: (children) => `<div data-markdown-table><table>${children}</table></div>`,
+    tbody: (children) => `<tbody>${children}</tbody>`,
+    td: (children, meta) => `<td${meta?.align ? ` align="${meta.align}"` : ""}>${children}</td>`,
+    text: escapeHtml,
+    th: (children, meta) => `<th${meta?.align ? ` align="${meta.align}"` : ""}>${children}</th>`,
+    thead: (children) => `<thead>${children}</thead>`,
+    tr: (children) => `<tr>${children}</tr>`
+  }, markdownOptions);
+  return { codeBlocks, html, source };
+};
+
+// ../../src/services/agent/index.ts
 class AgentHistoryError extends Data.TaggedError("AgentHistoryError") {
 }
 var AgentStreamErrorDetails = Schema.Struct({
@@ -180,11 +250,42 @@ class AgentService extends Context.Service()("AgentService", {
         prompt: action.type === "message" ? action.text : [],
         toolkit
       });
+      const renderedRounds = Stream.suspend(() => {
+        let source = "";
+        return rounds.pipe(Stream.groupedWithin(32, "50 millis"), Stream.flatMap((events) => {
+          const output = [];
+          let textChanged = false;
+          const appendSnapshot = () => {
+            if (!textChanged)
+              return;
+            const compiled = compileMarkdown(source);
+            output.push({
+              type: "markdown-snapshot",
+              messageId,
+              html: compiled.html,
+              codeBlocks: compiled.codeBlocks
+            });
+            textChanged = false;
+          };
+          for (const event of events) {
+            if (event.type === "text-delta") {
+              source += event.delta;
+              textChanged = true;
+              output.push(event);
+              continue;
+            }
+            appendSnapshot();
+            output.push(event);
+          }
+          appendSnapshot();
+          return Stream.fromIterable(output);
+        }));
+      });
       const complete = Stream.fromEffect(Effect.gen(function* () {
         const history2 = yield* conversation.exportJson;
         return { type: "history", value: history2 };
       })).pipe(Stream.concat(Stream.succeed({ type: "finish" })));
-      const response = Stream.concat(rounds, complete).pipe(Stream.provideService(LanguageModel.LanguageModel, model), Stream.catch((error) => Stream.fromEffect(Effect.logError("Agent stream failed", streamErrorDetails(error))).pipe(Stream.drain, Stream.concat(Stream.make({
+      const response = Stream.concat(renderedRounds, complete).pipe(Stream.provideService(LanguageModel.LanguageModel, model), Stream.catch((error) => Stream.fromEffect(Effect.logError("Agent stream failed", streamErrorDetails(error))).pipe(Stream.drain, Stream.concat(Stream.make({
         type: "error",
         code: "stream-failed"
       }, { type: "finish" })))));

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

@@ -23,6 +23,10 @@ export declare const AgentToolMetadata: Schema.Struct<{
     readonly description: Schema.optional<Schema.String>;
     readonly destructive: Schema.Boolean;
 }>;
+export declare const AgentMarkdownCodeBlock: Schema.Struct<{
+    readonly code: Schema.String;
+    readonly language: Schema.String;
+}>;
 export declare const AgentEvent: Schema.Union<readonly [Schema.Struct<{
     readonly type: Schema.Literal<"message-start">;
     readonly messageId: Schema.String;
@@ -30,6 +34,14 @@ export declare const AgentEvent: Schema.Union<readonly [Schema.Struct<{
     readonly type: Schema.Literal<"text-delta">;
     readonly messageId: Schema.String;
     readonly delta: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"markdown-snapshot">;
+    readonly messageId: Schema.String;
+    readonly html: Schema.String;
+    readonly codeBlocks: Schema.$Array<Schema.Struct<{
+        readonly code: Schema.String;
+        readonly language: Schema.String;
+    }>>;
 }>, Schema.Struct<{
     readonly type: Schema.Literal<"tool-call">;
     readonly messageId: Schema.String;
@@ -93,6 +105,14 @@ export declare const makeAgentApiGroup: <const Resource extends Schema.Top>(reso
     readonly type: Schema.Literal<"text-delta">;
     readonly messageId: Schema.String;
     readonly delta: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"markdown-snapshot">;
+    readonly messageId: Schema.String;
+    readonly html: Schema.String;
+    readonly codeBlocks: Schema.$Array<Schema.Struct<{
+        readonly code: Schema.String;
+        readonly language: Schema.String;
+    }>>;
 }>, Schema.Struct<{
     readonly type: Schema.Literal<"tool-call">;
     readonly messageId: Schema.String;
@@ -130,6 +150,14 @@ export declare const makeAgentApiGroup: <const Resource extends Schema.Top>(reso
     readonly type: Schema.Literal<"text-delta">;
     readonly messageId: Schema.String;
     readonly delta: Schema.String;
+}, "Type"> | Schema.Struct.ReadonlySide<{
+    readonly type: Schema.Literal<"markdown-snapshot">;
+    readonly messageId: Schema.String;
+    readonly html: Schema.String;
+    readonly codeBlocks: Schema.$Array<Schema.Struct<{
+        readonly code: Schema.String;
+        readonly language: Schema.String;
+    }>>;
 }, "Type"> | Schema.Struct.ReadonlySide<{
     readonly type: Schema.Literal<"tool-call">;
     readonly messageId: Schema.String;

package/dist/services/agent/schema.js

@@ -43,6 +43,10 @@ var AgentToolMetadata = Schema.Struct({
   description: Schema.optional(Schema.String),
   destructive: Schema.Boolean
 }).annotate({ identifier: "AgentToolMetadata" });
+var AgentMarkdownCodeBlock = Schema.Struct({
+  code: Schema.String,
+  language: Schema.String
+}).annotate({ identifier: "AgentMarkdownCodeBlock" });
 var AgentEvent = Schema.Union([
   Schema.Struct({
     type: Schema.Literal("message-start"),
@@ -53,6 +57,12 @@ var AgentEvent = Schema.Union([
     messageId: Schema.String,
     delta: Schema.String
   }),
+  Schema.Struct({
+    type: Schema.Literal("markdown-snapshot"),
+    messageId: Schema.String,
+    html: Schema.String,
+    codeBlocks: Schema.Array(AgentMarkdownCodeBlock)
+  }),
   Schema.Struct({
     type: Schema.Literal("tool-call"),
     messageId: Schema.String,
@@ -122,9 +132,10 @@ var makeAgentApiGroup = (resource) => {
   })));
 };
 export {
-  makeAgentReference,
-  makeAgentApiGroup,
-  AgentToolMetadata,
+  AGENT_REFERENCE_LIMIT,
   AgentEvent,
-  AGENT_REFERENCE_LIMIT
+  AgentMarkdownCodeBlock,
+  AgentToolMetadata,
+  makeAgentApiGroup,
+  makeAgentReference
 };

package/dist/services/file-extraction/index.js

@@ -111,9 +111,9 @@ class FileExtractionService extends Context.Service()("FileExtractionService", {
   static testLayer = (service) => Layer.succeed(this, service);
 }
 export {
-  defaultFileExtractionOptions,
-  OutputFormat2 as OutputFormat,
-  FileExtractionService,
+  FileExtractedTextSchema,
   FileExtractionFailed,
-  FileExtractedTextSchema
+  FileExtractionService,
+  OutputFormat2 as OutputFormat,
+  defaultFileExtractionOptions
 };

package/dist/services/file-extraction/schema.js

@@ -9,6 +9,6 @@ var FileExtractedTextSchema = Schema.Struct({
 class FileExtractionFailed extends Schema.TaggedErrorClass()("FileExtractionFailed", { message: Schema.String }) {
 }
 export {
-  FileExtractionFailed,
-  FileExtractedTextSchema
+  FileExtractedTextSchema,
+  FileExtractionFailed
 };

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";