@shivaedev/server 0.3.0 → 0.4.0

package/README.md

@@ -13,7 +13,7 @@ import { appHost } from "@shivaedev/server/appHost.ts";
 import { Api, Handlers, Services, migrations, sessions } from "./app.ts";
 
 NodeRuntime.runMain(
-  Layer.launch(appHost({ group: Api, handlers: Handlers, services: Services, migrations: { loader: migrations }, sessions, assets: "./public" })),
+	Layer.launch(appHost({ group: Api, handlers: Handlers, services: Services, migrations: { loader: migrations }, sessions, assets: "./public" })),
 );
 ```
 
@@ -35,7 +35,7 @@ The optional modules solve different boundaries. `runtime/` carries Effect servi
 
 ### Host the application
 
-`appHost` is the server entry point for an Effect app. For a PostgreSQL app, supply the native RPC group, handler and service Layers, migration loader, session policy and static asset directory. The host completes migrations before acquiring application services, starts Node HTTP with NDJSON RPC at `/rpc`, and provides SQL, Reactivity and `AppChanges` to those Layers.
+`appHost` is the server entry point for an Effect app. For a PostgreSQL app, supply the native RPC group, handler and service Layers, migration loader, session policy and static asset directory. The host completes migrations before acquiring application services, starts Node HTTP with native Effect RPC over a WebSocket upgrade at `/rpc`, and provides SQL, Reactivity and `AppChanges` to those Layers.
 
 ```ts
 import { NodeRuntime } from "@effect/platform-node";
@@ -44,12 +44,12 @@ import { appHost } from "@shivaedev/server/appHost.ts";
 import { Api, Handlers, Services, migrations, sessions } from "./app.ts";
 
 const Server = appHost({
-  group: Api,
-  handlers: Handlers,
-  services: Services,
-  migrations: { loader: migrations },
-  sessions,
-  assets: "./public",
+	group: Api,
+	handlers: Handlers,
+	services: Services,
+	migrations: { loader: migrations },
+	sessions,
+	assets: "./public",
 });
 
 NodeRuntime.runMain(Layer.launch(Server));
@@ -65,15 +65,15 @@ Pass application HTTP endpoints through `routes`, including routes that read app
 import { Effect, Layer } from "effect";
 import { HttpMiddleware, HttpRouter, HttpServerResponse } from "effect/http";
 
-const Routes = HttpRouter.add(
-  "*",
-  "/.well-known/app",
-  AppMetadata.pipe(Effect.map(HttpServerResponse.text)),
-).pipe(
-  Layer.provide(HttpRouter.middleware(HttpMiddleware.cors({
-    allowedOrigins: ["*"],
-    allowedMethods: ["GET"],
-  })).layer),
+const Routes = HttpRouter.add("*", "/.well-known/app", AppMetadata.pipe(Effect.map(HttpServerResponse.text))).pipe(
+	Layer.provide(
+		HttpRouter.middleware(
+			HttpMiddleware.cors({
+				allowedOrigins: ["*"],
+				allowedMethods: ["GET"],
+			}),
+		).layer,
+	),
 );
 
 const Server = appHost({ group: Api, handlers: Handlers, services: Services, routes: Routes, sessions });
@@ -89,7 +89,7 @@ RPC request bodies are limited to 1 MiB by default. Set `MAX_BODY_SIZE` to a byt
 
 For a native Node HTTP route outside RPC, read the request body with `readBoundedBody` from [`@shivaedev/http`](https://github.com/ShivaeDev/platform/tree/main/packages/http#readme), which rejects oversized bodies with a typed 413 failure.
 
-RPC uses the existing `localRpcGuard`: it requires a loopback peer and Host, same-origin or absent Origin, and the NDJSON content type. Session lookup uses transport headers. The host applies `RequestTracing` last to every served RPC, including loopback RPC, so it wraps authentication and handlers without a per-contract tracing declaration. Existing tracing declarations run once at that outermost boundary. With a session policy, contracts declare `Authenticated` and `MaybeAuthenticated` as needed; the host supplies their implementations. For `AuthenticatedUser`, merge `authenticatedUserLayer(sessions)` beside the handlers as shown below. Declared errors retain their Schema types. Applications still own resource authorization and use `rpcBoundary` when they need to map unexpected failures.
+Ordinary POST RPC uses `localRpcGuard` from `@shivaedev/identity/server/local.ts`: it requires a loopback peer and Host, same-origin or absent Origin, and the NDJSON content type. The WebSocket upgrade uses the same loopback, origin and trusted-proxy checks without an HTTP body content type. Session lookup uses the upgrade's transport headers; RPC message headers cannot replace its cookie or Origin. Session middleware revalidates authenticated streams at `streamRevalidationInterval` and ends revoked subscriptions with typed `Unauthorized`. The shared socket remains open; later protected calls use the same session checks. Automatic live subscriptions also recheck the session and query policy before each hint. POST RPC has no `$changes` stream. The host applies `RequestTracing` last to every served RPC, including loopback RPC, so it wraps authentication and handlers without a per-contract tracing declaration. Existing tracing declarations run once at that outermost boundary. With a session policy, contracts declare `Authenticated` and `MaybeAuthenticated` as needed; the host supplies their implementations. For `AuthenticatedUser`, merge `authenticatedUserLayer(sessions)` from `@shivaedev/identity/server/session.ts` beside the handlers. Declared errors retain their Schema types. Applications still own resource authorization and use `rpcBoundary` when they need to map unexpected failures.
 
 Every response from the host's native RPC endpoint carries `Cache-Control: private, no-store`, including mixed public and authenticated batches, typed failures, transport rejections, body-read failures and streams. The host sets this at the outer response boundary without inspecting batch contents.
 
@@ -103,7 +103,7 @@ Set `migrations.mode: "check"` on `appDatabase` or a database-backed `appHost` w
 
 Pass `migrations.components` beside `loader` for storage managed by another engine. For pg-boss, register `pgBossSchema({ schema: "app_jobs" })` from `@shivaedev/jobs/server/schema.ts`, then start every jobs Layer with `migrate: false`. `check` and `wait` use the same `MigrationError` readout for pending ledger IDs and component names and details, including pg-boss’s installed and required versions.
 
-The host provides Effect's native `Crypto` service (`effect/Crypto`) to preflight, deferred application construction, application services and handlers. Generate invite codes and tokens through that service; see the [secure invite code example](../../docs/framework/README.md#secure-invite-codes-and-tokens). Use `Random` for non-secure choices.
+The host provides Effect's native `Crypto` service (`effect/Crypto`) to preflight, deferred application construction, application services and handlers. Generate invite codes and tokens through that service; see the [secure invite code example](https://github.com/ShivaeDev/platform/blob/main/docs/framework/README.md#secure-invite-codes-and-tokens). Use `Random` for non-secure choices.
 
 Supply `preflight: AppConfigLive` to `appHost` to build a native Layer before checking or applying migrations, or constructing the application. Use it to validate configuration such as app IDs, keys and invite lists. Its errors stay in the returned Layer's typed error channel, its requirements other than `Crypto` remain external requirements, and its services are available to migrations, application construction, services and RPC handlers as well as callers of the host Layer. Preflight resources close with the host scope. The option also works without migrations.
 
@@ -111,13 +111,13 @@ When construction itself touches the schema, use `appHost({ migrations, config,
 
 ```ts
 const host = appHost({
-  config: { databaseUrl },
-  migrations: { loader: migrations, mode: "check" },
-  preflight: AppConfigLive,
-  application: Effect.gen(function* () {
-    const { routes, sessions } = yield* makeAuth();
-    return { group: Api, handlers: Handlers, services: Services, routes, sessions };
-  }),
+	config: { databaseUrl },
+	migrations: { loader: migrations, mode: "check" },
+	preflight: AppConfigLive,
+	application: Effect.gen(function* () {
+		const { routes, sessions } = yield* makeAuth();
+		return { group: Api, handlers: Handlers, services: Services, routes, sessions };
+	}),
 });
 ```
 
@@ -127,27 +127,27 @@ Set `OTEL_EXPORTER_OTLP_ENDPOINT` or `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT` to exp
 
 The supported tracing variables and defaults are:
 
-| Variable | Default | Meaning |
-| --- | --- | --- |
-| `OTEL_EXPORTER_OTLP_ENDPOINT` | Unset | Collector base URL. |
-| `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT` | Base URL plus `/v1/traces` | Complete traces URL; takes precedence. |
-| `OTEL_EXPORTER_OTLP_PROTOCOL` | `http/protobuf` | `http/protobuf` or `http/json`. |
-| `OTEL_EXPORTER_OTLP_TRACES_PROTOCOL` | General protocol | Overrides the protocol for traces. |
-| `OTEL_EXPORTER_OTLP_HEADERS` | Empty | Comma-separated exporter headers. |
-| `OTEL_SERVICE_NAME` | Resource `service.name`, then `unknown_service` | Service name. |
-| `OTEL_SERVICE_VERSION` | Resource `service.version`, otherwise unset | Service version. |
-| `OTEL_RESOURCE_ATTRIBUTES` | Empty | Comma-separated resource attributes. |
-| `OTEL_EXPORTER_OTLP_TIMEOUT` | `10000` ms | Timeout for each HTTP export attempt, including its response body. |
-| `OTEL_EXPORTER_OTLP_TRACES_TIMEOUT` | General timeout | Overrides the request timeout for traces. |
-| `OTEL_BSP_SCHEDULE_DELAY` | `5000` ms | Effect tracer's batch export interval. |
-| `OTEL_BSP_MAX_EXPORT_BATCH_SIZE` | `1000` spans | Effect tracer's batch-size trigger. |
-| `OTEL_BSP_EXPORT_TIMEOUT` | `3000` ms | Effect tracer's shutdown flush bound, capped at the request timeout. |
+| Variable                             | Default                                         | Meaning                                                              |
+| ------------------------------------ | ----------------------------------------------- | -------------------------------------------------------------------- |
+| `OTEL_EXPORTER_OTLP_ENDPOINT`        | Unset                                           | Collector base URL.                                                  |
+| `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT` | Base URL plus `/v1/traces`                      | Complete traces URL; takes precedence.                               |
+| `OTEL_EXPORTER_OTLP_PROTOCOL`        | `http/protobuf`                                 | `http/protobuf` or `http/json`.                                      |
+| `OTEL_EXPORTER_OTLP_TRACES_PROTOCOL` | General protocol                                | Overrides the protocol for traces.                                   |
+| `OTEL_EXPORTER_OTLP_HEADERS`         | Empty                                           | Comma-separated exporter headers.                                    |
+| `OTEL_SERVICE_NAME`                  | Resource `service.name`, then `unknown_service` | Service name.                                                        |
+| `OTEL_SERVICE_VERSION`               | Resource `service.version`, otherwise unset     | Service version.                                                     |
+| `OTEL_RESOURCE_ATTRIBUTES`           | Empty                                           | Comma-separated resource attributes.                                 |
+| `OTEL_EXPORTER_OTLP_TIMEOUT`         | `10000` ms                                      | Timeout for each HTTP export attempt, including its response body.   |
+| `OTEL_EXPORTER_OTLP_TRACES_TIMEOUT`  | General timeout                                 | Overrides the request timeout for traces.                            |
+| `OTEL_BSP_SCHEDULE_DELAY`            | `5000` ms                                       | Effect tracer's batch export interval.                               |
+| `OTEL_BSP_MAX_EXPORT_BATCH_SIZE`     | `1000` spans                                    | Effect tracer's batch-size trigger.                                  |
+| `OTEL_BSP_EXPORT_TIMEOUT`            | `3000` ms                                       | Effect tracer's shutdown flush bound, capped at the request timeout. |
 
 Timeouts fail through the HTTP client's typed transport-error channel and use the same warning path as other transport failures. Effect retains its native retry policy; the request timeout applies to each attempt. The batch defaults follow Effect's `OtlpTracer.layer`. Its options cannot express a separate batch-operation deadline or a queue capacity, so `OTEL_BSP_EXPORT_TIMEOUT` controls shutdown only and `OTEL_BSP_MAX_QUEUE_SIZE` is unsupported. Other `OTEL_BSP_*` variables are unsupported.
 
 On Railway, enable the per-service tracing setting separately for the web service and worker, and leave both exporter endpoint variables unset in your app's configuration. Railway documents that it injects the `OTEL_*` variables, including `OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf`, only when the app sets no endpoint of its own. The framework exports through Effect's own `effect/observability` OTLP tracer; eBPF auto-instrumentation is outside this path. For a worker, provide `otlpTracing` from `@shivaedev/server/otlpTracing.ts` to its application Layer. It batches ended Effect spans and flushes during scoped shutdown with a three-second bound by default. The first failed export logs a warning with the collector status and redacted response body, or the transport failure kind when no response arrives. Repeated failures stay quiet until a successful export. Collector connection failures and HTTP errors leave requests, jobs and shutdown successful.
 
-Exported HTTP server spans use `{method} {route}` with `http.route` for matched RPC and router paths, including parameter templates; unmatched requests use the method alone. The production host continues incoming W3C `traceparent` context, including one sent by an edge proxy.
+Exported HTTP server spans use `{method} {route}` with `http.route` for matched RPC and router paths, including parameter templates; unmatched requests use the method alone. `appHost` continues incoming W3C `traceparent` context in RPC handling, including one sent by an edge proxy, whether or not an exporter is configured.
 
 Both JSON and protobuf export serialization apply sensitive-key and credential-text redaction to span attributes, events, links, error details and resource attributes. Credential text includes JWTs, Bearer/Basic credentials, sensitive assignments including bare `sig=...` anywhere in text (with or without `?`), and complete PEM private-key blocks through their matching END marker, including RSA, EC, OPENSSH and encrypted private keys. Matches become `<redacted>`. `sig` uses the shared sensitive-key policy for attributes and text. URL query values, fragments and user information are also redacted. Exporter headers stay in the collector request, outside the spans. Applications must still avoid placing secrets in span names, free text or custom attributes.
 
@@ -167,11 +167,7 @@ Use one `publicConfig` declaration per application as the one path for server co
 import { Schema } from "effect";
 import { publicConfig } from "@shivaedev/contract/publicConfig.ts";
 
-export const PublicConfig = publicConfig(
-  Schema.Struct({ installUrl: Schema.URL }).pipe(
-    Schema.encodeKeys({ installUrl: "INSTALL_URL" }),
-  ),
-);
+export const PublicConfig = publicConfig(Schema.Struct({ installUrl: Schema.URL }).pipe(Schema.encodeKeys({ installUrl: "INSTALL_URL" })));
 ```
 
 On the server, merge the declaration into the application's group and its generated handler Layer into the handlers:
@@ -184,35 +180,27 @@ import { Api, Handlers, sessions } from "./app.ts";
 import { PublicConfig } from "./public-config.ts";
 
 export const Server = appHost({
-  group: Api.merge(PublicConfig),
-  handlers: Layer.merge(Handlers, publicConfigLayer(PublicConfig)),
-  sessions,
+	group: Api.merge(PublicConfig),
+	handlers: Layer.merge(Handlers, publicConfigLayer(PublicConfig)),
+	sessions,
 });
 ```
 
 `publicConfigLayer` reads `Config.schema` from the host's native ConfigProvider when the handler Layer builds. Missing or invalid required fields fail startup with a typed `ConfigError`. An optional second argument supplies a native Config path: `publicConfigLayer(PublicConfig, "PUBLIC")` reads `PUBLIC_INSTALL_URL` with the default environment provider. Only schema-declared fields are loaded and serialized; other server values never enter this response. The generated query has no session middleware, so it can supply public configuration before sign-in. Merge it alongside authenticated contracts rather than applying authentication to the merged group.
 
-On the client, use the same native `AtomRpc.Service`, NDJSON HTTP protocol and contract `bind` as other queries:
+On the client, use the same contract `makeClient` and shared WebSocket as other queries:
 
 ```ts
-import { Layer } from "effect";
-import { FetchHttpClient } from "effect/http";
-import * as AtomRpc from "effect/reactivity/AtomRpc";
-import { RpcClient, RpcSerialization } from "effect/rpc";
-import { bind } from "@shivaedev/contract/bind.ts";
+import { makeClient } from "@shivaedev/contract/bind.ts";
 import { useQuery } from "@shivaedev/react/client/resultState.ts";
 import { PublicConfig } from "./public-config.ts";
 
-class ConfigClient extends AtomRpc.Service<ConfigClient>()("app/ConfigClient", {
-  group: PublicConfig,
-  protocol: RpcClient.layerProtocolHttp({ url: "/rpc" }).pipe(
-    Layer.provide([FetchHttpClient.layer, RpcSerialization.layerNdjson]),
-  ),
-}) {}
-const config = bind(PublicConfig, ConfigClient);
+const { api: config } = makeClient(PublicConfig, {
+	url: new URL("/rpc", window.location.href).href,
+});
 
 export function usePublicConfig() {
-  return useQuery(config.get.query());
+	return useQuery(config.get.query());
 }
 ```
 
@@ -228,15 +216,15 @@ Tracing logs declared failures with `RPC failure` and their tag, and defects wit
 import { Schema } from "effect";
 
 const Contact = Schema.Struct({
-  deliveryAddress: Schema.String.annotate({ sensitive: true }),
-  recoveryCode: Schema.RedactedFromValue(Schema.String),
+	deliveryAddress: Schema.String.annotate({ sensitive: true }),
+	recoveryCode: Schema.RedactedFromValue(Schema.String),
 });
 
 const Server = appHost({
-  group: Api,
-  handlers: Handlers,
-  sessions,
-  config: { sensitiveKeys: ["customerReference"] },
+	group: Api,
+	handlers: Handlers,
+	sessions,
+	config: { sensitiveKeys: ["customerReference"] },
 });
 ```
 
@@ -252,7 +240,7 @@ For native RPC serialization, `schemaSensitiveKeys(group, extraKeys?)` returns a
 
 The masking primitives, `redact`, `redactWire`, `redactText`, `redactCause` and `isSensitiveKey`, live in [`@shivaedev/errors`](https://github.com/ShivaeDev/platform/tree/main/packages/errors#readme).
 
-For a native RPC server composed without `appHost`, `requestTracingLayer({ sensitive })` accepts a key predicate; `isSensitiveKey` from `@shivaedev/errors/sensitive.ts` supplies the default credential rules. `redactingErrorReporter(reporter, sensitive?)` from `@shivaedev/errors/redactCause.ts` wraps an Effect error reporter and passes it redacted failure and defect causes while preserving reporting hints such as severity and redacted attributes.
+For a native RPC server composed without `appHost`, `requestTracingLayer({ sensitive })` from `@shivaedev/identity/server/tracing.ts` accepts a key predicate; `isSensitiveKey` from `@shivaedev/errors/sensitive.ts` supplies the default credential rules. `redactingErrorReporter(reporter, sensitive?)` from `@shivaedev/errors/redactCause.ts` wraps an Effect error reporter and passes it redacted failure and defect causes while preserving reporting hints such as severity and redacted attributes.
 
 ### Calling outside APIs
 
@@ -270,13 +258,10 @@ class Greeting extends Context.Service<Greeting, string>()("app/Greeting") {}
 
 const runtime = makePlatformRuntime(Layer.succeed(Greeting, "application"));
 const base = await runtime.runPromise(Greeting);
-const request = await runtime.runWithServices(
-  Context.make(Greeting, "request"),
-  async () => {
-    await Promise.resolve();
-    return runtime.runPromise(Greeting);
-  },
-);
+const request = await runtime.runWithServices(Context.make(Greeting, "request"), async () => {
+	await Promise.resolve();
+	return runtime.runPromise(Greeting);
+});
 await runtime.dispose();
 ```
 
@@ -293,21 +278,21 @@ import type { IncomingMessage } from "node:http";
 import { nodeSubscriptionSignal } from "@shivaedev/server/node-http/subscriptionSignal.ts";
 
 export async function consumeSubscription(
-  request: Request,
-  nodeRequest: IncomingMessage,
-  procedureSignal: AbortSignal,
-  consume: (signal: AbortSignal) => Promise<void>,
+	request: Request,
+	nodeRequest: IncomingMessage,
+	procedureSignal: AbortSignal,
+	consume: (signal: AbortSignal) => Promise<void>,
 ) {
-  const subscription = nodeSubscriptionSignal({
-    nodeRequest,
-    request,
-    signals: [procedureSignal],
-  });
-  try {
-    await consume(subscription.signal);
-  } finally {
-    subscription.dispose();
-  }
+	const subscription = nodeSubscriptionSignal({
+		nodeRequest,
+		request,
+		signals: [procedureSignal],
+	});
+	try {
+		await consume(subscription.signal);
+	} finally {
+		subscription.dispose();
+	}
 }
 ```
 
@@ -317,29 +302,32 @@ The signal aborts on an additional signal, socket close, incomplete request clos
 
 Import the module that defines the name; there is no package-root entry. Paths below follow `@shivaedev/server/`.
 
-| Module | Names and purpose |
-| --- | --- |
-| `appHost.ts` | `appHost`, `appDatabase`, `AppChanges`: scoped HTTP and PostgreSQL composition with loopback defaults and optional proxy trust. |
-| `otlpTracing.ts` | `otlpTracing`: opt-in Effect OTLP trace export for worker Layers. |
-| `schemaSensitiveKeys.ts`, `RedactionPolicy.ts` | `schemaSensitiveKeys(group, extraKeys?)`, `RedactionPolicy`: derive and provide an app's diagnostic key predicate. |
-| `redactingDiagnostics.ts`, `redactingTracer.ts`, `redactingRpcSerialization.ts` | `redactingDiagnostics(sensitive)`, `redactRecord(values, sensitive)`, `redactingTracer(sensitive)`, `redactingRpcSerialization(wire, sensitive)`: compose native diagnostic and NDJSON boundaries. |
-| `runtime/makePlatform.ts` | `makePlatformRuntime(layer, { developmentCacheKey? })`. |
-| `node-http/subscriptionSignal.ts` | `nodeSubscriptionSignal({ nodeRequest?, request?, signals? })`, returning `{ signal, dispose }`. |
+| Module                                                                          | Names and purpose                                                                                                                                                                                                |
+| ------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `appHost.ts`                                                                    | `appHost`, `appDatabase`, `AppChanges`: scoped HTTP and PostgreSQL composition with loopback defaults and optional proxy trust.                                                                                  |
+| `setupDatabases.ts`                                                             | `setupDatabases()`: prepare the local development and test databases.                                                                                                                                            |
+| `development.ts`                                                                | `development({ server, worker, conditions? })`, `runDevelopment(options)`: run the server, worker and Vite in watch mode.                                                                                        |
+| `rpc-server/publicConfigLayer.ts`                                               | `publicConfigLayer(declaration, path?)`: serve a `publicConfig` declaration from native Config.                                                                                                                  |
+| `otlpTracing.ts`                                                                | `otlpTracing`: opt-in Effect OTLP trace export for worker Layers.                                                                                                                                                |
+| `schemaSensitiveKeys.ts`, `RedactionPolicy.ts`                                  | `schemaSensitiveKeys(group, extraKeys?)`, `RedactionPolicy`: derive and provide an app's diagnostic key predicate.                                                                                               |
+| `redactingDiagnostics.ts`, `redactingTracer.ts`, `redactingRpcSerialization.ts` | `redactingDiagnostics(sensitive)`, `redactRecord(values, sensitive)`, `redactingTracer(sensitive)`, `redactingRpcSerialization(wire, sensitive, maskFailure?)`: compose native diagnostic and NDJSON boundaries. |
+| `runtime/makePlatform.ts`                                                       | `makePlatformRuntime(layer, { developmentCacheKey? })`.                                                                                                                                                          |
+| `node-http/subscriptionSignal.ts`                                               | `nodeSubscriptionSignal({ nodeRequest?, request?, signals? })`, returning `{ signal, dispose }`.                                                                                                                 |
 
 ### Install, setup and limits
 
 ```sh
-pnpm add @shivaedev/server effect@4.0.5
+pnpm add @shivaedev/server effect
 ```
 
 Effect is the only required peer. The `node-http/`, `rpc-server/` and `runtime/` modules work without the optional peers; a module's import path is its path under `src/`. Every module is server code: the runtime uses Node's `AsyncLocalStorage`, and browser code imports contracts from `@shivaedev/contract`, identity declarations from `@shivaedev/identity` and error schemas from `@shivaedev/errors` instead.
 
 Install the optional peers for the selected integration:
 
-| Integration | Additional peers |
-| --- | --- |
-| `appHost.ts` | `@effect/platform-node`, `@effect/sql-pg` |
-
+| Integration      | Additional peers                          |
+| ---------------- | ----------------------------------------- |
+| `appHost.ts`     | `@effect/platform-node`, `@effect/sql-pg` |
+| `development.ts` | `@effect/platform-node`                   |
 - The package needs Node 24 or newer.
 - `appHost` adds tracing last on its server-side copy of the group. When composing a native RPC server directly, add `RequestTracing` last on the group so it wraps authentication too; see the [native-server example](https://github.com/ShivaeDev/platform/blob/main/docs/framework/request-context.md#request-id-identity-and-logging). Middleware outside that tracing boundary is responsible for its own diagnostics.
 - Redaction recognizes declared field names and common credential shapes. Mark sensitive fields in RPC schemas and configure extra names once with `config.sensitiveKeys`. Keep sensitive values out of ordinary prose.

package/dist/appHost.js

@@ -1,4 +1,4 @@
-import { NodeCrypto } from "@effect/platform-node";
+import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
 import { Context, Layer } from "effect";
 import { appHostHttp, deferredHost, migratedHost } from "#appHostHttp.ts";
 import { databaseLayer } from "#databaseLayer.ts";

package/dist/appHost.js.map

@@ -1 +1 @@
-{"version":3,"file":"appHost.js","sourceRoot":"","sources":["../src/appHost.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,OAAO,EAAe,KAAK,EAAE,MAAM,QAAQ,CAAC;AAMrD,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC1E,OAAO,EAAuB,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAIvE,MAAM,OAAO,UAAW,SAAQ,OAAO,CAAC,OAAO,EAAqD,CAAC,8BAA8B,CAAC;CAAG;AAMvI,MAAM,UAAU,WAAW,CAAI,OAA8B;IAC5D,OAAO,aAAa,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;AAC3C,CAAC;AAiED,MAAM,CAAC,MAAM,OAAO,GAAmB,CAkBtC,OAiBC,EACA,EAAE;IACH,IAAI,aAAa,IAAI,OAAO,EAAE,CAAC;QAC9B,OAAO,YAAY,CAAC,OAAO,CAAC,WAAW,EAAE,WAAW,CAAC,OAAO,CAAC,EAAE,UAAU,CAAC,CAAC,IAAI,CAC9E,KAAK,CAAC,YAAY,CAAC,OAAO,CAAC,SAAS,IAAI,KAAK,CAAC,KAAK,CAAC,EACpD,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,KAAK,CAAC,CAC/B,CAAC;IACH,CAAC;IACD,OAAO,OAAO,CAAC,UAAU,KAAK,SAAS;QACtC,CAAC,CAAC,WAAW,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,OAAO,CAAC,SAAS,IAAI,KAAK,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QAC9H,CAAC,CAAC,YAAY,CAAC,EAAE,GAAG,OAAO,EAAE,UAAU,EAAE,OAAO,CAAC,UAAU,EAAE,EAAE,WAAW,CAAC,EAAE,GAAG,OAAO,EAAE,UAAU,EAAE,OAAO,CAAC,UAAU,EAAE,CAAC,EAAE,UAAU,CAAC,CAAC,IAAI,CAC1I,KAAK,CAAC,YAAY,CAAC,OAAO,CAAC,SAAS,IAAI,KAAK,CAAC,KAAK,CAAC,EACpD,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,KAAK,CAAC,CAC/B,CAAC;AACL,CAAC,CAAC"}
+{"version":3,"file":"appHost.js","sourceRoot":"","sources":["../src/appHost.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,kCAAkC,CAAC;AAC/D,OAAO,EAAE,OAAO,EAAe,KAAK,EAAE,MAAM,QAAQ,CAAC;AAMrD,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC1E,OAAO,EAAuB,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAIvE,MAAM,OAAO,UAAW,SAAQ,OAAO,CAAC,OAAO,EAAqD,CAAC,8BAA8B,CAAC;CAAG;AAMvI,MAAM,UAAU,WAAW,CAAI,OAA8B;IAC5D,OAAO,aAAa,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;AAC3C,CAAC;AAiED,MAAM,CAAC,MAAM,OAAO,GAAmB,CAkBtC,OAiBC,EACA,EAAE;IACH,IAAI,aAAa,IAAI,OAAO,EAAE,CAAC;QAC9B,OAAO,YAAY,CAAC,OAAO,CAAC,WAAW,EAAE,WAAW,CAAC,OAAO,CAAC,EAAE,UAAU,CAAC,CAAC,IAAI,CAC9E,KAAK,CAAC,YAAY,CAAC,OAAO,CAAC,SAAS,IAAI,KAAK,CAAC,KAAK,CAAC,EACpD,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,KAAK,CAAC,CAC/B,CAAC;IACH,CAAC;IACD,OAAO,OAAO,CAAC,UAAU,KAAK,SAAS;QACtC,CAAC,CAAC,WAAW,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,OAAO,CAAC,SAAS,IAAI,KAAK,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QAC9H,CAAC,CAAC,YAAY,CAAC,EAAE,GAAG,OAAO,EAAE,UAAU,EAAE,OAAO,CAAC,UAAU,EAAE,EAAE,WAAW,CAAC,EAAE,GAAG,OAAO,EAAE,UAAU,EAAE,OAAO,CAAC,UAAU,EAAE,CAAC,EAAE,UAAU,CAAC,CAAC,IAAI,CAC1I,KAAK,CAAC,YAAY,CAAC,OAAO,CAAC,SAAS,IAAI,KAAK,CAAC,KAAK,CAAC,EACpD,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,KAAK,CAAC,CAC/B,CAAC;AACL,CAAC,CAAC"}