@krak-stack/registry 0.1.39 → 0.1.41

package/dist/components/ui/google-map.js

@@ -1,5 +1,5 @@
 // ../../src/components/ui/google-map.tsx
-import { Minus, Plus } from "lucide-react";
+import { LocateFixed, Minus, Plus } from "lucide-react";
 import { useEffect, useEffectEvent, useRef, useState } from "react";
 import { Schema } from "effect";
 
@@ -8,7 +8,7 @@ import { cn } from "cn";
 
 // ../../src/components/ui/google-map.tsx
 import { useKrakstackLocale } from "@krak-stack/registry/krakstack-provider";
-import { jsx, jsxs } from "react/jsx-runtime";
+import { jsx, jsxs, Fragment } from "react/jsx-runtime";
 var googleMapsScriptId = "krak-stack-google-maps-script";
 var googleMapsCallbackName = "__krakStackGoogleMapsInit";
 var googleMapsPromise;
@@ -21,7 +21,8 @@ var defaultMessages = {
     errorTitle: "Map unavailable",
     errorBody: "Google Maps could not be loaded. Try again later.",
     zoomIn: "Zoom in",
-    zoomOut: "Zoom out"
+    zoomOut: "Zoom out",
+    showArea: "Show selected area"
   },
   fr: {
     mapLabel: "Carte Google",
@@ -31,7 +32,8 @@ var defaultMessages = {
     errorTitle: "Carte indisponible",
     errorBody: "Impossible de charger Google Maps. Réessayez plus tard.",
     zoomIn: "Zoom avant",
-    zoomOut: "Zoom arrière"
+    zoomOut: "Zoom arrière",
+    showArea: "Afficher la zone sélectionnée"
   }
 };
 var googleMapMessages = (locale, translations) => ({
@@ -104,6 +106,8 @@ function GoogleMap({
   radius,
   interactive = true,
   zoomControls = true,
+  fitRadius = false,
+  fitPadding = 32,
   minZoom = 3,
   maxZoom = 20,
   className,
@@ -135,6 +139,18 @@ function GoogleMap({
   const radiusStrokeColor = radius?.strokeColor;
   const radiusStrokeOpacity = radius?.strokeOpacity;
   const radiusStrokeWeight = radius?.strokeWeight;
+  const showSelectedArea = () => {
+    try {
+      const element = mapElementRef.current;
+      const bounds = circleRef.current?.getBounds()?.toJSON();
+      if (!element?.clientWidth || !element.clientHeight || !bounds)
+        return;
+      mapRef.current?.fitBounds(bounds, Math.max(0, fitPadding));
+    } catch {
+      setLoadState("error");
+    }
+  };
+  const fitSelection = useEffectEvent(showSelectedArea);
   const initializeMap = useEffectEvent((api, element) => {
     const map = new api.maps.Map(element, mapOptions(center, zoom, interactive, normalizedMinZoom, normalizedMaxZoom));
     apiRef.current = api;
@@ -182,17 +198,36 @@ function GoogleMap({
     };
   }, [normalizedApiKey]);
   useEffect(() => {
-    const api = apiRef.current;
     const map = mapRef.current;
-    if (loadState !== "ready" || !api || !map)
+    if (loadState !== "ready" || !map)
       return;
+    const nextCenter = { lat: centerLat, lng: centerLng };
+    const nextZoom = clampZoom(zoom, normalizedMinZoom, normalizedMaxZoom);
     try {
-      const nextCenter = { lat: centerLat, lng: centerLng };
-      const nextZoom = clampZoom(zoom, normalizedMinZoom, normalizedMaxZoom);
+      map.setOptions(mapOptions(nextCenter, nextZoom, interactive, normalizedMinZoom, normalizedMaxZoom));
       map.setCenter(nextCenter);
       map.setZoom(nextZoom);
-      map.setOptions(mapOptions(nextCenter, nextZoom, interactive, normalizedMinZoom, normalizedMaxZoom));
       setCurrentZoom(nextZoom);
+    } catch {
+      setLoadState("error");
+    }
+  }, [
+    centerLat,
+    centerLng,
+    zoom,
+    interactive,
+    fitRadius,
+    normalizedMinZoom,
+    normalizedMaxZoom,
+    loadState
+  ]);
+  useEffect(() => {
+    const api = apiRef.current;
+    const map = mapRef.current;
+    if (loadState !== "ready" || !api || !map)
+      return;
+    try {
+      const nextCenter = { lat: centerLat, lng: centerLng };
       if (markerEnabled) {
         if (markerRef.current) {
           markerRef.current.setMap(map);
@@ -241,19 +276,46 @@ function GoogleMap({
   }, [
     centerLat,
     centerLng,
-    interactive,
     loadState,
     markerEnabled,
     markerIcon,
-    normalizedMaxZoom,
-    normalizedMinZoom,
     radiusFillColor,
     radiusFillOpacity,
     radiusMeters,
     radiusStrokeColor,
     radiusStrokeOpacity,
-    radiusStrokeWeight,
-    zoom
+    radiusStrokeWeight
+  ]);
+  useEffect(() => {
+    const element = mapElementRef.current;
+    if (loadState !== "ready" || !fitRadius || radiusMeters === undefined || !element)
+      return;
+    fitSelection();
+    if (!globalThis.ResizeObserver)
+      return;
+    let width = element.clientWidth;
+    let height = element.clientHeight;
+    const observer = new ResizeObserver(() => {
+      const nextWidth = element.clientWidth;
+      const nextHeight = element.clientHeight;
+      if (nextWidth === width && nextHeight === height)
+        return;
+      width = nextWidth;
+      height = nextHeight;
+      fitSelection();
+    });
+    observer.observe(element);
+    return () => observer.disconnect();
+  }, [
+    loadState,
+    fitRadius,
+    fitPadding,
+    interactive,
+    centerLat,
+    centerLng,
+    radiusMeters,
+    normalizedMinZoom,
+    normalizedMaxZoom
   ]);
   const changeZoom = (delta) => {
     const map = mapRef.current;
@@ -264,7 +326,7 @@ function GoogleMap({
     setCurrentZoom(nextZoom);
   };
   return /* @__PURE__ */ jsxs("div", {
-    className: cn("bg-muted relative min-h-64 overflow-hidden rounded-lg border", className),
+    className: cn("bg-muted relative isolate min-h-64 min-w-0 overflow-hidden rounded-lg border", className),
     children: [
       /* @__PURE__ */ jsx("div", {
         ref: mapElementRef,
@@ -273,11 +335,28 @@ function GoogleMap({
         "aria-label": labels.mapLabel
       }),
       loadState === "ready" && zoomControls ? /* @__PURE__ */ jsxs("div", {
-        className: "bg-background/95 absolute right-4 bottom-4 z-10 overflow-hidden rounded-md border shadow-sm backdrop-blur",
+        className: "bg-background/95 absolute top-3 right-3 z-10 overflow-hidden rounded-md border shadow-sm backdrop-blur",
         children: [
+          fitRadius && radiusMeters !== undefined ? /* @__PURE__ */ jsxs(Fragment, {
+            children: [
+              /* @__PURE__ */ jsx("button", {
+                type: "button",
+                onClick: showSelectedArea,
+                "aria-label": labels.showArea,
+                title: labels.showArea,
+                className: "text-foreground hover:bg-accent focus-visible:ring-ring relative flex size-11 items-center justify-center focus-visible:z-10 focus-visible:ring-2 focus-visible:ring-inset",
+                children: /* @__PURE__ */ jsx(LocateFixed, {
+                  className: "size-4"
+                })
+              }),
+              /* @__PURE__ */ jsx("div", {
+                className: "bg-border h-px"
+              })
+            ]
+          }) : null,
           /* @__PURE__ */ jsx("button", {
             type: "button",
-            className: "text-muted-foreground hover:bg-accent hover:text-accent-foreground flex size-9 items-center justify-center transition-colors disabled:pointer-events-none disabled:opacity-50",
+            className: "text-foreground hover:bg-accent focus-visible:ring-ring relative flex size-11 items-center justify-center transition-colors focus-visible:z-10 focus-visible:ring-2 focus-visible:ring-inset disabled:pointer-events-none disabled:opacity-50",
             disabled: currentZoom >= normalizedMaxZoom,
             onClick: () => changeZoom(1),
             "aria-label": labels.zoomIn,
@@ -290,7 +369,7 @@ function GoogleMap({
           }),
           /* @__PURE__ */ jsx("button", {
             type: "button",
-            className: "text-muted-foreground hover:bg-accent hover:text-accent-foreground flex size-9 items-center justify-center transition-colors disabled:pointer-events-none disabled:opacity-50",
+            className: "text-foreground hover:bg-accent focus-visible:ring-ring relative flex size-11 items-center justify-center transition-colors focus-visible:z-10 focus-visible:ring-2 focus-visible:ring-inset disabled:pointer-events-none disabled:opacity-50",
             disabled: currentZoom <= normalizedMinZoom,
             onClick: () => changeZoom(-1),
             "aria-label": labels.zoomOut,

package/dist/lib/query.d.ts

@@ -29,8 +29,8 @@ export declare const SortParams: Schema.declare<readonly {
     readonly direction: "asc" | "desc";
 }[]>;
 export declare const Query: Schema.Struct<{
-    readonly page: Schema.decodeTo<Schema.Int, Schema.optionalKey<Schema.Union<readonly [Schema.Number, Schema.NumberFromString]>>, never, never>;
-    readonly pageSize: Schema.decodeTo<Schema.Int, Schema.optionalKey<Schema.Union<readonly [Schema.Number, Schema.NumberFromString]>>, never, never>;
+    readonly page: Schema.decodeTo<Schema.Int, Schema.optional<Schema.Union<readonly [Schema.Number, Schema.NumberFromString]>>, never, never>;
+    readonly pageSize: Schema.decodeTo<Schema.Int, Schema.optional<Schema.Union<readonly [Schema.Number, Schema.NumberFromString]>>, never, never>;
     readonly globalFilter: Schema.optional<Schema.String>;
     readonly sort: Schema.optional<Schema.declare<readonly {
         readonly id: string;
@@ -42,7 +42,34 @@ export declare const Query: Schema.Struct<{
 }>;
 export type QueryType = typeof Query.Type;
 export type QueryEncoded = typeof Query.Encoded;
-export declare const QueryStandard: ReturnType<typeof Schema.toStandardSchemaV1<typeof Query>>;
+export declare const QueryStandard: import("effect/StandardSchema").StandardSchemaV1<{
+    readonly globalFilter?: string | undefined;
+    readonly sort?: readonly {
+        readonly id: string;
+        readonly direction: "asc" | "desc";
+    }[] | undefined;
+    readonly page?: string | number | undefined;
+    readonly pageSize?: string | number | undefined;
+}, {
+    readonly globalFilter?: string | undefined;
+    readonly sort?: readonly {
+        readonly id: string;
+        readonly direction: "asc" | "desc";
+    }[] | undefined;
+    readonly page?: number | undefined;
+    readonly pageSize?: number | undefined;
+}> & Schema.Struct<{
+    readonly globalFilter: Schema.optional<Schema.String>;
+    readonly sort: Schema.optional<Schema.declare<readonly {
+        readonly id: string;
+        readonly direction: "asc" | "desc";
+    }[], readonly {
+        readonly id: string;
+        readonly direction: "asc" | "desc";
+    }[]>>;
+    readonly page: Schema.decodeTo<Schema.optional<Schema.Int>, Schema.decodeTo<Schema.Int, Schema.optional<Schema.Union<readonly [Schema.Number, Schema.NumberFromString]>>, never, never>, never, never>;
+    readonly pageSize: Schema.decodeTo<Schema.optional<Schema.Int>, Schema.decodeTo<Schema.Int, Schema.optional<Schema.Union<readonly [Schema.Number, Schema.NumberFromString]>>, never, never>, never, never>;
+}>;
 export declare const PaginationMeta: Schema.Struct<{
     readonly page: Schema.Int;
     readonly pageSize: Schema.Int;

package/dist/lib/query.js

@@ -81,11 +81,11 @@ var SortParams = Schema.declare(Schema.is(SortParamsArray), {
   toCodecStringTree: () => Schema.link()(SortParamsFromString, SchemaTransformation.passthrough())
 });
 var Query = Schema.Struct({
-  page: Schema.optionalKey(Schema.Union([Schema.Number, Schema.NumberFromString]).check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(0))).pipe(Schema.decodeTo(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)), {
+  page: Schema.optional(Schema.Union([Schema.Number, Schema.NumberFromString]).check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(0))).pipe(Schema.decodeTo(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)), {
     decode: SchemaGetter.withDefault(Effect.succeed(0)),
     encode: SchemaGetter.transformOptional(Option.filter((page) => page !== 0))
   })),
-  pageSize: Schema.optionalKey(Schema.Union([Schema.Number, Schema.NumberFromString]).check(Schema.isInt(), Schema.isBetween({ minimum: 1, maximum: 100 }))).pipe(Schema.decodeTo(Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 100 })), {
+  pageSize: Schema.optional(Schema.Union([Schema.Number, Schema.NumberFromString]).check(Schema.isInt(), Schema.isBetween({ minimum: 1, maximum: 100 }))).pipe(Schema.decodeTo(Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 100 })), {
     decode: SchemaGetter.withDefault(Effect.succeed(20)),
     encode: SchemaGetter.transformOptional(Option.filter((pageSize) => pageSize !== 20))
   })),
@@ -107,7 +107,17 @@ var Query = Schema.Struct({
     }
   ]
 });
-var QueryStandard = Schema.toStandardSchemaV1(Query);
+var QueryStandard = Schema.toStandardSchemaV1(Schema.Struct({
+  ...Query.fields,
+  page: Query.fields.page.pipe(Schema.decodeTo(Schema.optional(Schema.Int), {
+    decode: SchemaGetter.transform((page) => page === 0 ? undefined : page),
+    encode: SchemaGetter.transform((page) => page ?? 0)
+  })),
+  pageSize: Query.fields.pageSize.pipe(Schema.decodeTo(Schema.optional(Schema.Int), {
+    decode: SchemaGetter.transform((pageSize) => pageSize === 20 ? undefined : pageSize),
+    encode: SchemaGetter.transform((pageSize) => pageSize ?? 20)
+  }))
+}).annotate({ identifier: "QuerySearch" }));
 var PaginationMeta = Schema.Struct({
   page: Schema.Int,
   pageSize: Schema.Int,

package/dist/services/opentelemetry/api.d.ts

@@ -1,5 +1,5 @@
 import { Config, Layer } from "effect";
 import { HttpRouter } from "effect/http";
 export declare class HttpApiOtlp {
-    static readonly layer: Layer.Layer<import("effect/FileSystem").FileSystem | import("effect/http/Etag").Generator | import("effect/http/HttpPlatform").HttpPlatform | import("effect/Path").Path, Config.ConfigError, HttpRouter.HttpRouter>;
+    static readonly layer: Layer.Layer<import("effect/FileSystem").FileSystem | import("effect/observability/OtlpExporter").Flusher | import("effect/http/Etag").Generator | import("effect/http/HttpPlatform").HttpPlatform | import("./events.js").OtlpEvents | import("effect/Path").Path, Config.ConfigError, HttpRouter.HttpRouter>;
 }

package/dist/services/opentelemetry/api.js

@@ -1,7 +1,7 @@
 // ../../src/services/opentelemetry/api.ts
-import { Config, Effect, Layer, Schema } from "effect";
+import { Config as Config2, Effect as Effect3, Layer as Layer3, Schema as Schema4 } from "effect";
 import {
-  FetchHttpClient,
+  FetchHttpClient as FetchHttpClient2,
   HttpClient,
   HttpClientRequest,
   HttpMiddleware,
@@ -10,15 +10,167 @@ import {
   HttpServerRequest,
   HttpServerResponse
 } from "effect/http";
-import { Otlp, OtlpSerialization } from "effect/observability";
-var OpenTelemetryLive = Otlp.layerFromConfig().pipe(Layer.provide(OtlpSerialization.layerJson), Layer.provide(FetchHttpClient.layer));
+
+// ../../src/services/opentelemetry/server.ts
+import { Config, Effect as Effect2, Layer as Layer2, Schema as Schema3 } from "effect";
+import { FetchHttpClient } from "effect/http";
+import { Otlp, OtlpExporter as OtlpExporter2, OtlpSerialization as OtlpSerialization2 } from "effect/observability";
+
+// ../../src/services/opentelemetry/events.ts
+import {
+  Clock,
+  Context,
+  DateTime,
+  Effect,
+  Layer,
+  Option,
+  References,
+  Schema as Schema2
+} from "effect";
+import {
+  OtlpExporter,
+  OtlpResource,
+  OtlpSerialization
+} from "effect/observability";
+
+// ../../src/services/opentelemetry/schema.ts
+import { Schema } from "effect";
+var EventAttributeValue = Schema.Union([
+  Schema.String,
+  Schema.Finite,
+  Schema.Boolean,
+  Schema.Array(Schema.String),
+  Schema.Array(Schema.Finite),
+  Schema.Array(Schema.Boolean)
+]);
+var EventAttributesSchema = Schema.Record(Schema.String, EventAttributeValue).annotate({ identifier: "EventAttributes" });
+var EventOptionsSchema = Schema.Struct({
+  userId: Schema.optional(Schema.NonEmptyString),
+  anonymousId: Schema.optional(Schema.NonEmptyString),
+  sessionId: Schema.optional(Schema.NonEmptyString),
+  messageId: Schema.optional(Schema.NonEmptyString),
+  timestamp: Schema.optional(Schema.DateTimeUtc),
+  context: Schema.optional(EventAttributesSchema)
+}).annotate({ identifier: "EventOptions" });
+var TelemetryEvent = Schema.Struct({
+  name: Schema.NonEmptyString,
+  properties: Schema.optional(EventAttributesSchema),
+  options: Schema.optional(EventOptionsSchema)
+}).annotate({ identifier: "TelemetryEvent" });
+var PageEvent = Schema.Struct({
+  name: Schema.optional(Schema.NonEmptyString),
+  category: Schema.optional(Schema.NonEmptyString),
+  path: Schema.optional(Schema.NonEmptyString),
+  properties: Schema.optional(EventAttributesSchema),
+  options: Schema.optional(EventOptionsSchema)
+}).annotate({ identifier: "PageEvent" });
+var BrowserIdentity = Schema.Struct({
+  userId: Schema.optional(Schema.NonEmptyString),
+  organizationId: Schema.optional(Schema.NonEmptyString)
+}).annotate({ identifier: "BrowserTelemetryIdentity" });
+
+// ../../src/services/opentelemetry/events.ts
+class OtlpEvents extends Context.Service()("krakstack/opentelemetry/Events") {
+  static disabledLayer = Layer.succeed(this, { push: () => {} });
+  static layer = (options) => Layer.effect(this, Effect.gen(function* () {
+    const serialization = yield* OtlpSerialization.OtlpSerialization;
+    const resource = yield* OtlpResource.fromConfig(options.resource);
+    return yield* OtlpExporter.make({
+      ...options,
+      label: "OtlpEvents",
+      body: (logRecords) => [
+        serialization.logs({
+          resourceLogs: [
+            {
+              resource,
+              scopeLogs: [
+                {
+                  scope: { name: "krakstack.events" },
+                  logRecords
+                }
+              ]
+            }
+          ]
+        }),
+        Effect.void
+      ]
+    });
+  }));
+}
+var track = Effect.fnUntraced(function* (name, properties, options) {
+  const event = yield* Schema2.decodeUnknownEffect(TelemetryEvent)({
+    name,
+    properties,
+    options
+  });
+  const events = yield* OtlpEvents;
+  const clock = yield* Clock.Clock;
+  const observedTime = clock.currentTimeNanosUnsafe().toString();
+  const timestamp = event.options?.timestamp ? (BigInt(DateTime.toEpochMillis(event.options.timestamp)) * 1000000n).toString() : observedTime;
+  const span = yield* Effect.currentSpan.pipe(Effect.option);
+  const attributes = { ...event.options?.context, ...event.properties };
+  if (event.options?.userId)
+    attributes["user.id"] = event.options.userId;
+  if (event.options?.anonymousId)
+    attributes["analytics.anonymous_id"] = event.options.anonymousId;
+  if (event.options?.sessionId)
+    attributes["session.id"] = event.options.sessionId;
+  if (event.options?.messageId)
+    attributes["log.record.uid"] = event.options.messageId;
+  const annotations = yield* References.CurrentLogAnnotations;
+  events.push({
+    eventName: event.name,
+    timeUnixNano: timestamp,
+    observedTimeUnixNano: observedTime,
+    severityNumber: 9,
+    attributes: OtlpResource.entriesToAttributes(Object.entries({
+      ...attributes,
+      ...annotations
+    })),
+    droppedAttributesCount: 0,
+    traceId: Option.isSome(span) ? span.value.traceId : undefined,
+    spanId: Option.isSome(span) ? span.value.spanId : undefined
+  });
+});
+
+// ../../src/services/opentelemetry/server.ts
+var ServerEventsLive = Layer2.unwrap(Effect2.gen(function* () {
+  const disabled = yield* Config.Boolean("OTEL_SDK_DISABLED").pipe(Config.withDefault(false));
+  const exporters = yield* Config.Array(Schema3.String, "OTEL_LOGS_EXPORTER").pipe(Config.withDefault([]));
+  if (disabled || !exporters.some((value) => value.trim().toLowerCase() === "otlp")) {
+    return OtlpEvents.disabledLayer;
+  }
+  const endpoint = yield* Config.URL("OTEL_EXPORTER_OTLP_LOGS_ENDPOINT").pipe(Config.orElse(() => Config.URL("OTEL_EXPORTER_OTLP_ENDPOINT").pipe(Config.map((url) => {
+    url.pathname += `${url.pathname.endsWith("/") ? "" : "/"}v1/logs`;
+    return url;
+  }))), Config.withDefault(undefined));
+  if (!endpoint) {
+    return OtlpEvents.disabledLayer;
+  }
+  const headersConfig = (name) => Config.Record(Schema3.String, Schema3.StringFromUriComponent, name);
+  const headers = yield* headersConfig("OTEL_EXPORTER_OTLP_LOGS_HEADERS").pipe(Config.orElse(() => headersConfig("OTEL_EXPORTER_OTLP_HEADERS")), Config.withDefault(undefined));
+  return OtlpEvents.layer({
+    url: endpoint.toString(),
+    headers,
+    exportInterval: "1 second",
+    maxBatchSize: 1000,
+    shutdownTimeout: "3 seconds"
+  });
+}).pipe(Effect2.orDie));
+
+class ServerOtlp {
+  static track = track;
+  static layer = Layer2.mergeAll(Otlp.layerFromConfig(), ServerEventsLive).pipe(Layer2.provideMerge(OtlpExporter2.layerFlusher), Layer2.provide(OtlpSerialization2.layerJson), Layer2.provide(FetchHttpClient.layer));
+}
+
+// ../../src/services/opentelemetry/api.ts
 var otlpProxyPaths = [
   "/api/otel/v1/traces",
   "/api/otel/v1/metrics",
   "/api/otel/v1/logs"
 ];
-var exporterConfig = (signal) => Config.Array(Schema.String, `OTEL_${signal}_EXPORTER`).pipe(Config.map((exporters) => exporters.map((exporter) => exporter.toLowerCase().trim())), Config.withDefault([]));
-var proxyOtlp = (baseUrl, signal) => Effect.gen(function* () {
+var exporterConfig = (signal) => Config2.Array(Schema4.String, `OTEL_${signal}_EXPORTER`).pipe(Config2.map((exporters) => exporters.map((exporter) => exporter.toLowerCase().trim())), Config2.withDefault([]));
+var proxyOtlp = (baseUrl, signal) => Effect3.gen(function* () {
   const incoming = yield* HttpServerRequest.HttpServerRequest;
   const client = yield* HttpClient.HttpClient;
   const contentType = incoming.headers["content-type"] ?? "application/json";
@@ -33,20 +185,20 @@ var proxyOtlp = (baseUrl, signal) => Effect.gen(function* () {
       "retry-after": upstream.headers["retry-after"]
     }
   });
-}).pipe(Effect.withTracerEnabled(false), HttpMiddleware.withLoggerDisabled, Effect.catch((error) => Effect.logError("Failed to proxy browser telemetry", error).pipe(Effect.as(HttpServerResponse.empty({ status: 502 })))), Effect.provide(FetchHttpClient.layer));
-var otlpProxyLayer = Layer.unwrap(Effect.gen(function* () {
-  const baseUrl = yield* Config.URL("OTEL_EXPORTER_OTLP_ENDPOINT");
-  const exporters = yield* Config.all({
+}).pipe(Effect3.withTracerEnabled(false), HttpMiddleware.withLoggerDisabled, Effect3.catch((error) => Effect3.logError("Failed to proxy browser telemetry", error).pipe(Effect3.as(HttpServerResponse.empty({ status: 502 })))), Effect3.provide(FetchHttpClient2.layer));
+var otlpProxyLayer = Layer3.unwrap(Effect3.gen(function* () {
+  const baseUrl = yield* Config2.URL("OTEL_EXPORTER_OTLP_ENDPOINT");
+  const exporters = yield* Config2.all({
     logs: exporterConfig("LOGS"),
     metrics: exporterConfig("METRICS"),
     traces: exporterConfig("TRACES")
   });
-  return Layer.mergeAll(exporters.traces.includes("otlp") ? HttpRouter.add("POST", otlpProxyPaths[0], proxyOtlp(baseUrl, "traces")) : Layer.empty, exporters.metrics.includes("otlp") ? HttpRouter.add("POST", otlpProxyPaths[1], proxyOtlp(baseUrl, "metrics")) : Layer.empty, exporters.logs.includes("otlp") ? HttpRouter.add("POST", otlpProxyPaths[2], proxyOtlp(baseUrl, "logs")) : Layer.empty);
+  return Layer3.mergeAll(exporters.traces.includes("otlp") ? HttpRouter.add("POST", otlpProxyPaths[0], proxyOtlp(baseUrl, "traces")) : Layer3.empty, exporters.metrics.includes("otlp") ? HttpRouter.add("POST", otlpProxyPaths[1], proxyOtlp(baseUrl, "metrics")) : Layer3.empty, exporters.logs.includes("otlp") ? HttpRouter.add("POST", otlpProxyPaths[2], proxyOtlp(baseUrl, "logs")) : Layer3.empty);
 }));
-var serverServices = HttpServer.layerServices.pipe(Layer.provideMerge(HttpMiddleware.layerTracerDisabledForUrls(otlpProxyPaths)));
+var serverServices = HttpServer.layerServices.pipe(Layer3.provideMerge(HttpMiddleware.layerTracerDisabledForUrls(otlpProxyPaths)));
 
 class HttpApiOtlp {
-  static layer = Layer.mergeAll(OpenTelemetryLive, otlpProxyLayer, serverServices);
+  static layer = Layer3.mergeAll(ServerOtlp.layer, otlpProxyLayer, serverServices);
 }
 export {
   HttpApiOtlp

package/dist/services/opentelemetry/browser.d.ts

@@ -1,5 +1,15 @@
-import { Layer } from "effect";
+import { Context, Effect, Layer, Ref, Schema } from "effect";
 import { type Otlp, OtlpExporter, OtlpLogger, OtlpMetrics, OtlpTracer } from "effect/observability";
+import { OtlpEvents, type EventExportOptions } from "./events.js";
+import { BrowserIdentity, type EventAttributes, type EventOptions, type PageOptions } from "./schema.js";
+export type { BrowserIdentity, EventAttributes, EventOptions, PageOptions, } from "./schema.js";
+declare const BrowserIdentityState_base: Context.ServiceClass<BrowserIdentityState, "krakstack/opentelemetry/BrowserIdentity", Ref.Ref<{
+    readonly userId?: string | undefined;
+    readonly organizationId?: string | undefined;
+}>>;
+declare class BrowserIdentityState extends BrowserIdentityState_base {
+    static readonly layer: Layer.Layer<BrowserIdentityState, never, never>;
+}
 type OtlpOptions = Parameters<typeof Otlp.layerJson>[0];
 type SignalOptions<Options> = Omit<Options, "url" | "resource" | "headers">;
 export interface BrowserOtlpOptions {
@@ -11,8 +21,16 @@ export interface BrowserOtlpOptions {
     readonly traces?: false | SignalOptions<Parameters<typeof OtlpTracer.layer>[0]>;
     readonly metrics?: false | SignalOptions<Parameters<typeof OtlpMetrics.layer>[0]>;
     readonly logs?: false | SignalOptions<Parameters<typeof OtlpLogger.layer>[0]>;
+    readonly events?: false | (EventExportOptions & {
+        /** Initial page and pathname changes; enabled by default. */
+        readonly pageViews?: boolean;
+    });
 }
 export declare class BrowserOtlp {
-    static readonly layer: ({ attributes, baseUrl, logs, metrics, serviceName, serviceVersion, traces, headers, }: BrowserOtlpOptions) => Layer.Layer<OtlpExporter.Flusher, never, never>;
+    /** Uses the active browser layer; invalid identity warns without failing or changing state. */
+    static readonly identify: (identity: BrowserIdentity | null) => Effect.Effect<void, never, never>;
+    static readonly track: (name: string, properties?: EventAttributes, options?: EventOptions) => Effect.Effect<void, Schema.SchemaError, never>;
+    static readonly page: (options?: PageOptions) => Effect.Effect<void, Schema.SchemaError, never>;
+    static readonly pageView: (options?: PageOptions) => Effect.Effect<void, Schema.SchemaError, never>;
+    static readonly layer: ({ attributes, baseUrl, logs, events, metrics, serviceName, serviceVersion, traces, headers, }: BrowserOtlpOptions) => Layer.Layer<BrowserIdentityState | OtlpExporter.Flusher | OtlpEvents, never, never>;
 }
-export {};