@aryasaatvik/motel 0.3.0

package/src/otlp.ts

@@ -0,0 +1,162 @@
+export interface OtlpAnyValue {
+	readonly stringValue?: string
+	readonly boolValue?: boolean
+	readonly intValue?: string | number
+	readonly doubleValue?: number
+	readonly bytesValue?: string
+	readonly arrayValue?: {
+		readonly values?: readonly OtlpAnyValue[]
+	}
+	readonly kvlistValue?: {
+		readonly values?: readonly OtlpKeyValue[]
+	}
+}
+
+export interface OtlpKeyValue {
+	readonly key: string
+	readonly value?: OtlpAnyValue
+}
+
+export interface OtlpSpanEvent {
+	readonly timeUnixNano?: string
+	readonly name?: string
+	readonly attributes?: readonly OtlpKeyValue[]
+}
+
+export interface OtlpSpan {
+	readonly traceId: string
+	readonly spanId: string
+	readonly parentSpanId?: string
+	readonly name?: string
+	readonly kind?: number
+	readonly startTimeUnixNano?: string
+	readonly endTimeUnixNano?: string
+	readonly attributes?: readonly OtlpKeyValue[]
+	readonly status?: {
+		readonly code?: number
+		readonly message?: string
+	}
+	readonly events?: readonly OtlpSpanEvent[]
+}
+
+export interface OtlpScopeSpans {
+	readonly scope?: {
+		readonly name?: string
+	}
+	readonly spans?: readonly OtlpSpan[]
+}
+
+export interface OtlpResourceSpans {
+	readonly resource?: {
+		readonly attributes?: readonly OtlpKeyValue[]
+	}
+	readonly scopeSpans?: readonly OtlpScopeSpans[]
+}
+
+export interface OtlpTraceExportRequest {
+	readonly resourceSpans?: readonly OtlpResourceSpans[]
+}
+
+export interface OtlpLogRecord {
+	readonly timeUnixNano?: string
+	readonly observedTimeUnixNano?: string
+	readonly severityText?: string
+	readonly body?: OtlpAnyValue
+	readonly attributes?: readonly OtlpKeyValue[]
+	readonly traceId?: string
+	readonly spanId?: string
+}
+
+export interface OtlpScopeLogs {
+	readonly scope?: {
+		readonly name?: string
+	}
+	readonly logRecords?: readonly OtlpLogRecord[]
+}
+
+export interface OtlpResourceLogs {
+	readonly resource?: {
+		readonly attributes?: readonly OtlpKeyValue[]
+	}
+	readonly scopeLogs?: readonly OtlpScopeLogs[]
+}
+
+export interface OtlpLogExportRequest {
+	readonly resourceLogs?: readonly OtlpResourceLogs[]
+}
+
+export const parseAnyValue = (value: OtlpAnyValue | undefined): unknown => {
+	if (!value) return null
+	if (value.stringValue !== undefined) return value.stringValue
+	if (value.boolValue !== undefined) return value.boolValue
+	if (value.intValue !== undefined) return Number(value.intValue)
+	if (value.doubleValue !== undefined) return value.doubleValue
+	if (value.bytesValue !== undefined) return value.bytesValue
+	if (value.arrayValue?.values) return value.arrayValue.values.map(parseAnyValue)
+	if (value.kvlistValue?.values) {
+		return Object.fromEntries(value.kvlistValue.values.map((entry) => [entry.key, parseAnyValue(entry.value)]))
+	}
+	return null
+}
+
+export const stringifyValue = (value: unknown): string => {
+	if (value === null || value === undefined) return ""
+	if (typeof value === "string") return value
+	if (typeof value === "number" || typeof value === "boolean") return String(value)
+	if (Array.isArray(value)) {
+		return value.map((entry) => stringifyValue(entry)).filter((entry) => entry.length > 0).join(" ")
+	}
+	return JSON.stringify(value)
+}
+
+export const attributeMap = (attributes: readonly OtlpKeyValue[] | undefined): Record<string, string> =>
+	Object.fromEntries((attributes ?? []).map((attribute) => [attribute.key, stringifyValue(parseAnyValue(attribute.value))]))
+
+export const nanosToMilliseconds = (value: string | undefined): number => {
+	if (!value) return 0
+	try {
+		return Number(BigInt(value) / 1_000_000n)
+	} catch {
+		const parsed = Number.parseInt(value, 10)
+		return Number.isFinite(parsed) ? Math.floor(parsed / 1_000_000) : 0
+	}
+}
+
+export const spanKindLabel = (kind: number | undefined): string | null => {
+	switch (kind) {
+		case 1:
+			return "internal"
+		case 2:
+			return "server"
+		case 3:
+			return "client"
+		case 4:
+			return "producer"
+		case 5:
+			return "consumer"
+		default:
+			return null
+	}
+}
+
+export const spanStatusLabel = (code: number | undefined): "ok" | "error" => (code === 2 ? "error" : "ok")
+
+/** Normalize OTLP hex or canonical base64 binary IDs to lowercase hex. */
+export const normalizeOtlpBinaryId = (
+	value: string | null | undefined,
+	expectedBytes: 8 | 16,
+): string | null => {
+	if (!value) return null
+	const expectedHexLength = expectedBytes * 2
+	if (value.length === expectedHexLength && /^[0-9a-f]+$/.test(value)) return value
+	if (value.length === expectedHexLength && /^[0-9a-fA-F]+$/.test(value)) return value.toLowerCase()
+	try {
+		const bytes = Buffer.from(value, "base64")
+		if (bytes.length === expectedBytes && bytes.toString("base64") === value) {
+			return bytes.toString("hex")
+		}
+	} catch {
+		// Preserve non-standard human-readable IDs used by local fixtures and custom exporters.
+	}
+	return value
+}

package/src/otlpProtobuf.ts

@@ -0,0 +1,35 @@
+import rootModule from "@opentelemetry/otlp-transformer/build/esm/generated/root.js"
+import type { OtlpLogExportRequest, OtlpTraceExportRequest } from "./otlp.js"
+
+interface ProtobufType {
+	readonly decode: (bytes: Uint8Array) => unknown
+	readonly toObject: (message: unknown, options: Record<string, unknown>) => unknown
+}
+
+const root = rootModule as unknown as {
+	readonly opentelemetry: {
+		readonly proto: {
+			readonly collector: {
+				readonly trace: { readonly v1: { readonly ExportTraceServiceRequest: ProtobufType } }
+				readonly logs: { readonly v1: { readonly ExportLogsServiceRequest: ProtobufType } }
+			}
+		}
+	}
+}
+
+const ExportTraceServiceRequest = root.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest
+const ExportLogsServiceRequest = root.opentelemetry.proto.collector.logs.v1.ExportLogsServiceRequest
+const decodeOptions = {
+	bytes: String,
+	longs: String,
+	defaults: false,
+	enums: Number,
+	arrays: true,
+	objects: true,
+}
+
+export const decodeProtobufTraces = (bytes: Uint8Array): OtlpTraceExportRequest =>
+	ExportTraceServiceRequest.toObject(ExportTraceServiceRequest.decode(bytes), decodeOptions) as OtlpTraceExportRequest
+
+export const decodeProtobufLogs = (bytes: Uint8Array): OtlpLogExportRequest =>
+	ExportLogsServiceRequest.toObject(ExportLogsServiceRequest.decode(bytes), decodeOptions) as OtlpLogExportRequest

package/src/queryFilters.ts

@@ -0,0 +1,39 @@
+export const ATTRIBUTE_FILTER_PREFIX = "attr."
+export const ATTRIBUTE_CONTAINS_PREFIX = "attrContains."
+
+export const isAttributeFilterToken = (value: string) => value.startsWith(ATTRIBUTE_FILTER_PREFIX) && value.includes("=")
+export const isAttributeContainsToken = (value: string) => value.startsWith(ATTRIBUTE_CONTAINS_PREFIX) && value.includes("=")
+
+export const attributeFiltersFromEntries = (entries: Iterable<readonly [string, string]>) =>
+	Object.fromEntries(
+		[...entries]
+			.filter(([key]) => key.startsWith(ATTRIBUTE_FILTER_PREFIX) && !key.startsWith(ATTRIBUTE_CONTAINS_PREFIX))
+			.map(([key, value]) => [key.slice(ATTRIBUTE_FILTER_PREFIX.length), value]),
+	)
+
+export const attributeContainsFiltersFromEntries = (entries: Iterable<readonly [string, string]>) =>
+	Object.fromEntries(
+		[...entries]
+			.filter(([key]) => key.startsWith(ATTRIBUTE_CONTAINS_PREFIX))
+			.map(([key, value]) => [key.slice(ATTRIBUTE_CONTAINS_PREFIX.length), value]),
+	)
+
+export const attributeFiltersFromArgs = (values: readonly string[]) =>
+	Object.fromEntries(
+		values
+			.filter((v) => isAttributeFilterToken(v) && !isAttributeContainsToken(v))
+			.map((value) => {
+				const index = value.indexOf("=")
+				return [value.slice(ATTRIBUTE_FILTER_PREFIX.length, index), value.slice(index + 1)]
+			}),
+	)
+
+export const attributeContainsFiltersFromArgs = (values: readonly string[]) =>
+	Object.fromEntries(
+		values
+			.filter(isAttributeContainsToken)
+			.map((value) => {
+				const index = value.indexOf("=")
+				return [value.slice(ATTRIBUTE_CONTAINS_PREFIX.length, index), value.slice(index + 1)]
+			}),
+	)

package/src/registry.ts

@@ -0,0 +1,115 @@
+import * as fs from "node:fs"
+import * as os from "node:os"
+import * as path from "node:path"
+import packageJson from "../package.json" with { type: "json" }
+
+export const MOTEL_VERSION = packageJson.version
+export const MOTEL_SERVICE_ID = "motel-local-server"
+
+const stateHome = () =>
+	process.env.XDG_STATE_HOME?.trim() || path.join(os.homedir(), ".local", "state")
+
+/**
+ * The shared, machine-global motel state directory. Holds the SQLite
+ * database, daemon log, daemon lock, and the per-pid instance registry.
+ * One motel daemon serves every project on this machine — there is no
+ * per-cwd state.
+ */
+export const motelStateDir = () => process.env.MOTEL_RUNTIME_DIR?.trim() || path.join(stateHome(), "motel")
+
+export const registryDir = (runtimeDir = motelStateDir()) => path.join(runtimeDir, "instances")
+
+export type RegistryEntry = {
+	readonly pid: number
+	readonly url: string
+	readonly workdir: string
+	readonly startedAt: string
+	readonly version: string
+	readonly instanceId?: string
+	readonly processIdentity?: string
+	/**
+	 * The SQLite database path the daemon is serving. Optional because
+	 * older daemon builds omit it; consumers should treat a missing
+	 * value as "unknown" and fall back to whatever validation path
+	 * they would have used before this field existed (typically an
+	 * HTTP /api/health probe).
+	 */
+	readonly databasePath?: string
+}
+
+const entryPath = (pid: number, runtimeDir = motelStateDir()) => path.join(registryDir(runtimeDir), `${pid}.json`)
+
+export const isAlive = (pid: number): boolean => {
+	try {
+		process.kill(pid, 0)
+		return true
+	} catch (err) {
+		return (err as NodeJS.ErrnoException).code === "EPERM"
+	}
+}
+
+export const processIdentity = (pid: number): string | null => {
+	try {
+		const result = Bun.spawnSync({ cmd: ["ps", "-p", String(pid), "-o", "lstart="] })
+		if (result.exitCode !== 0) return null
+		const identity = result.stdout.toString().trim()
+		return identity.length > 0 ? identity : null
+	} catch {
+		return null
+	}
+}
+
+export const isManagedDaemonProcess = (entry: RegistryEntry): boolean => {
+	return Boolean(entry.instanceId && entry.processIdentity && processIdentity(entry.pid) === entry.processIdentity)
+}
+
+export const listAliveEntries = (runtimeDir = motelStateDir()): RegistryEntry[] => {
+	const dir = registryDir(runtimeDir)
+	let files: string[]
+	try {
+		files = fs.readdirSync(dir)
+	} catch {
+		return []
+	}
+	const alive: RegistryEntry[] = []
+	for (const f of files) {
+		if (!f.endsWith(".json")) continue
+		const full = path.join(dir, f)
+		try {
+			const entry = JSON.parse(fs.readFileSync(full, "utf8")) as RegistryEntry
+			if (entry.instanceId && entry.processIdentity ? isManagedDaemonProcess(entry) : isAlive(entry.pid)) {
+				alive.push(entry)
+			} else {
+				try { fs.unlinkSync(full) } catch {}
+			}
+		} catch {
+			try { fs.unlinkSync(full) } catch {}
+		}
+	}
+	return alive
+}
+
+export const writeRegistryEntry = (entry: RegistryEntry, runtimeDir = motelStateDir()) => {
+	fs.mkdirSync(registryDir(runtimeDir), { recursive: true })
+	const file = entryPath(entry.pid, runtimeDir)
+	fs.writeFileSync(file, JSON.stringify(entry, null, 2), "utf8")
+}
+
+/**
+ * Remove this daemon's registry entry. Intended to be called from a
+ * Layer release so the scope-managed server shutdown removes the entry
+ * in the same finalizer chain that stops the socket. Historically this
+ * was done via ad-hoc process-signal handlers installed here that ran
+ * `process.exit(0)` — which races with the Effect runtime's own SIGINT
+ * handling and short-circuits the Bun server's graceful stop. The
+ * server (via BunRuntime.runMain) now owns signal handling; registry
+ * cleanup rides along on scope release.
+ */
+export const removeRegistryEntry = (pid: number, runtimeDir = motelStateDir()) => {
+	try {
+		fs.unlinkSync(entryPath(pid, runtimeDir))
+	} catch {
+		// Already gone — another cleanup path won the race, or the entry
+		// was never written.
+	}
+}

package/src/runtime.ts

@@ -0,0 +1,40 @@
+import * as NodeSdk from "@effect/opentelemetry/NodeSdk"
+import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http"
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http"
+import { SimpleLogRecordProcessor } from "@opentelemetry/sdk-logs"
+import { SimpleSpanProcessor } from "@opentelemetry/sdk-trace-base"
+import { Layer, ManagedRuntime } from "effect"
+import { config } from "./config.js"
+import { TelemetryStoreLive, TelemetryStoreReadonlyLive } from "./services/TelemetryStore.js"
+
+const telemetryLayer = NodeSdk.layer(() => ({
+	spanProcessor: new SimpleSpanProcessor(
+		new OTLPTraceExporter({
+			url: config.otel.exporterUrl,
+		}),
+	),
+	logRecordProcessor: new SimpleLogRecordProcessor(
+		new OTLPLogExporter({
+			url: config.otel.logsExporterUrl,
+		}),
+	),
+	loggerMergeWithExisting: false,
+	resource: {
+		serviceName: config.otel.serviceName,
+		attributes: {
+			"deployment.environment.name": "local",
+			"service.instance.id": "motel.local",
+		},
+	},
+}))
+
+// TUI-side runtime is readonly — a daemon/worker writer owns the DB
+// lock while ingests are in flight, and trying to grab the write lock
+// for schema init on startup causes "database is locked" on bun dev.
+const QueryRuntimeLive = config.otel.enabled ? Layer.mergeAll(TelemetryStoreReadonlyLive, telemetryLayer) : TelemetryStoreReadonlyLive
+
+export const queryRuntime = ManagedRuntime.make(QueryRuntimeLive)
+// `storeRuntime` is the full writer runtime, exposed for the telemetry
+// test suite (and any future tooling that needs the ingest side). The
+// TUI itself only consumes `queryRuntime`, which is readonly.
+export const storeRuntime = ManagedRuntime.make(TelemetryStoreLive)

package/src/server.ts

@@ -0,0 +1,11 @@
+import { BunRuntime } from "@effect/platform-bun"
+import { Layer } from "effect"
+import { ServerLive } from "./localServer.js"
+
+// `BunRuntime.runMain` installs signal handlers that interrupt the root
+// fiber on SIGINT/SIGTERM; `Layer.launch` holds the scope open until
+// then. On interruption the scope closes top-down: RegistryLayer's
+// release removes the daemon's registry entry, BunHttpServer's release
+// calls server.stop(), SQLite connections close — all through layer
+// finalizers instead of ad-hoc process.exit handlers.
+Layer.launch(ServerLive).pipe(BunRuntime.runMain)

package/src/services/AsyncIngest.ts

@@ -0,0 +1,82 @@
+/**
+ * Main-thread client for the telemetry worker's ingest RPCs.
+ *
+ * The HTTP handlers for POST /v1/traces and POST /v1/logs call into
+ * this service instead of `TelemetryStore.ingestTraces/Logs`. Each
+ * method sends a typed message to the worker, awaits the reply, and
+ * returns the worker's result as an Effect. While the worker is
+ * serialising a big batch into SQLite, the main thread's event loop
+ * is FREE to answer /api/* queries — that's the whole point of the
+ * offload. Without this, /api/health and friends queued behind long
+ * ingests and reported p95 latencies of 3-5 seconds; after, they
+ * stay responsive regardless of ingest load.
+ *
+ * The worker is spawned as a scope'd resource inside the layer. The
+ * protocol pool is sized at 1 because SQLite only supports a single
+ * writer at a time anyway — running N concurrent workers would just
+ * queue them on SQLite's lock. When the outer scope closes (server
+ * shutdown), `BunWorker.layer`'s finalizer sends a close message and
+ * terminates the worker if it doesn't exit gracefully in 5s.
+ */
+
+import * as BunWorker from "@effect/platform-bun/BunWorker"
+import { Context, Duration, Effect, Exit, Layer, Scope } from "effect"
+import * as RpcClient from "effect/unstable/rpc/RpcClient"
+import type { RpcClientError } from "effect/unstable/rpc/RpcClientError"
+import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization"
+import type { WorkerError } from "effect/unstable/workers/WorkerError"
+import { IngestRpcs } from "./ingestRpc.ts"
+
+// RpcClient.make always surfaces RpcClientError in addition to the
+// group's declared errors (transport failures, worker crashes, etc.),
+// so the service shape has to mirror that. Without the explicit error
+// type param, TS treats the declared and observed client types as
+// unrelated structural mismatches.
+export class AsyncIngest extends Context.Service<
+	AsyncIngest,
+	RpcClient.FromGroup<typeof IngestRpcs, RpcClientError | WorkerError>
+>()("@motel/AsyncIngest") {}
+
+// Protocol: RpcClient.layerProtocolWorker manages a worker pool and
+// speaks msgpack over structured-clone messages. `size: 1` matches
+// SQLite's single-writer constraint.
+const WorkerProtocol = RpcClient.layerProtocolWorker({ size: 1 }).pipe(
+	Layer.provide(RpcSerialization.layerMsgPack),
+	Layer.provide(
+		BunWorker.layer(() => new Worker(new URL("./telemetryWorker.ts", import.meta.url))),
+	),
+)
+
+export const AsyncIngestLive = Layer.effect(
+	AsyncIngest,
+	Effect.gen(function*() {
+		const scope = yield* Scope.Scope
+		// Keep daemon startup cheap: creating the RPC client here would eagerly
+		// spawn the worker and make /api/health wait on the worker's SQLite
+		// bootstrap. Cache a lazy initializer instead so the worker only starts
+		// on the first ingest request, but is still shared thereafter.
+		const [getClient, invalidateClient] = yield* Effect.cachedInvalidateWithTTL(Effect.gen(function*() {
+			const clientScope = yield* Scope.fork(scope, "sequential")
+			const protocolContext = yield* Layer.buildWithScope(WorkerProtocol, clientScope)
+			const client = yield* RpcClient.make(IngestRpcs).pipe(
+				Effect.provide(protocolContext),
+				Effect.provideService(Scope.Scope, clientScope),
+			)
+			return { client, clientScope }
+		}), Duration.infinity)
+		// Start the sole writer/maintenance worker immediately, but do not make
+		// HTTP health wait for SQLite bootstrap. Managed readiness still verifies
+		// the worker through explicit ingest probes.
+		yield* Effect.forkScoped(getClient.pipe(Effect.ignore))
+		return {
+			ingestTraces: (input, options) =>
+				Effect.flatMap(getClient, ({ client, clientScope }) => client.ingestTraces(input, options).pipe(
+					Effect.onError(() => Effect.andThen(Scope.close(clientScope, Exit.void), invalidateClient)),
+				)),
+			ingestLogs: (input, options) =>
+				Effect.flatMap(getClient, ({ client, clientScope }) => client.ingestLogs(input, options).pipe(
+					Effect.onError(() => Effect.andThen(Scope.close(clientScope, Exit.void), invalidateClient)),
+				)),
+		}
+	}),
+)

package/src/services/LogQueryService.ts

@@ -0,0 +1,29 @@
+import { Effect, Layer, Context } from "effect"
+import type { LogItem } from "../domain.js"
+import { TelemetryStore } from "./TelemetryStore.js"
+
+/**
+ * Compatibility adapter for consumers importing the historical log query module.
+ * New internal callers should use TelemetryStoreReadonly directly.
+ */
+export class LogQueryService extends Context.Service<
+	LogQueryService,
+	{
+		readonly listRecentLogs: (serviceName: string) => Effect.Effect<readonly LogItem[], Error>
+		readonly listTraceLogs: (traceId: string) => Effect.Effect<readonly LogItem[], Error>
+		readonly searchLogs: (input: { readonly serviceName?: string | null; readonly severity?: string | null; readonly traceId?: string | null; readonly spanId?: string | null; readonly body?: string | null; readonly lookbackMinutes?: number; readonly limit?: number; readonly cursorTimestampMs?: number; readonly cursorId?: string; readonly attributeFilters?: Readonly<Record<string, string>>; readonly attributeContainsFilters?: Readonly<Record<string, string>> }) => Effect.Effect<readonly LogItem[], Error>
+		readonly logStats: (input: { readonly groupBy: string; readonly agg: "count"; readonly serviceName?: string | null; readonly traceId?: string | null; readonly spanId?: string | null; readonly body?: string | null; readonly lookbackMinutes?: number; readonly limit?: number; readonly attributeFilters?: Readonly<Record<string, string>>; readonly attributeContainsFilters?: Readonly<Record<string, string>> }) => Effect.Effect<readonly { readonly group: string; readonly value: number; readonly count: number }[], Error>
+		readonly listFacets: (input: { readonly type: "traces" | "logs"; readonly field: string; readonly serviceName?: string | null; readonly lookbackMinutes?: number; readonly limit?: number }) => Effect.Effect<readonly { readonly value: string; readonly count: number }[], Error>
+	}
+>()("motel/LogQueryService") {}
+
+export const LogQueryServiceLive = Layer.effect(
+	LogQueryService,
+	Effect.map(TelemetryStore, (store) => LogQueryService.of({
+		listRecentLogs: store.listRecentLogs,
+		listTraceLogs: store.listTraceLogs,
+		searchLogs: store.searchLogs,
+		logStats: store.logStats,
+		listFacets: store.listFacets,
+	})),
+)

package/src/services/TelemetryQuery.ts

@@ -0,0 +1,62 @@
+import * as BunWorker from "@effect/platform-bun/BunWorker"
+import { Duration, Effect, Exit, Layer, Scope } from "effect"
+import * as RpcClient from "effect/unstable/rpc/RpcClient"
+import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization"
+import type { WorkerError } from "effect/unstable/workers/WorkerError"
+import type { RpcClientError } from "effect/unstable/rpc/RpcClientError"
+import { TelemetryStoreReadonly, type TelemetryStoreReader } from "./TelemetryStore.js"
+import { QueryRpcs } from "./queryRpc.js"
+
+type QueryMethod = keyof TelemetryStoreReader
+type QueryClient = RpcClient.FromGroup<typeof QueryRpcs, RpcClientError | WorkerError>
+type QueryClientEntry = { readonly client: QueryClient; readonly clientScope: Scope.Scope }
+
+const WorkerProtocol = RpcClient.layerProtocolWorker({ size: 1 }).pipe(
+	Layer.provide(RpcSerialization.layerMsgPack),
+	Layer.provide(BunWorker.layer(() => new Worker(new URL("./telemetryQueryWorker.ts", import.meta.url)))),
+)
+
+const query = <A>(getClient: Effect.Effect<QueryClientEntry, unknown>, invalidateClient: Effect.Effect<void>, method: QueryMethod, args: readonly unknown[] = []) =>
+	Effect.flatMap(getClient, ({ client, clientScope }) => client.query({ method, args }).pipe(
+		Effect.onError(() => Effect.andThen(Scope.close(clientScope, Exit.void), invalidateClient)),
+	)).pipe(
+		Effect.map((result) => result as A),
+		Effect.mapError((error) => error instanceof Error ? error : new Error(String(error))),
+	)
+
+export const TelemetryQueryLive = Layer.effect(
+	TelemetryStoreReadonly,
+	Effect.gen(function*() {
+		const scope = yield* Scope.Scope
+		const [getClient, invalidateClient] = yield* Effect.cachedInvalidateWithTTL(Effect.gen(function*() {
+			const clientScope = yield* Scope.fork(scope, "sequential")
+			const protocolContext = yield* Layer.buildWithScope(WorkerProtocol, clientScope)
+			const client = yield* RpcClient.make(QueryRpcs).pipe(
+				Effect.provide(protocolContext),
+				Effect.provideService(Scope.Scope, clientScope),
+			)
+			return { client, clientScope }
+		}), Duration.infinity)
+		const run = <A>(method: QueryMethod, args: readonly unknown[] = []) => query<A>(getClient, invalidateClient, method, args)
+		return TelemetryStoreReadonly.of({
+			listServices: run("listServices"),
+			listRecentTraces: (serviceName, options) => run("listRecentTraces", [serviceName, options]),
+			listTraceSummaries: (serviceName, options) => run("listTraceSummaries", [serviceName, options]),
+			searchTraces: (input) => run("searchTraces", [input]),
+			searchTraceSummaries: (input) => run("searchTraceSummaries", [input]),
+			traceStats: (input) => run("traceStats", [input]),
+			getTrace: (traceId) => run("getTrace", [traceId]),
+			getSpan: (spanId) => run("getSpan", [spanId]),
+			listTraceSpans: (traceId) => run("listTraceSpans", [traceId]),
+			searchSpans: (input) => run("searchSpans", [input]),
+			searchLogs: (input) => run("searchLogs", [input]),
+			logStats: (input) => run("logStats", [input]),
+			listFacets: (input) => run("listFacets", [input]),
+			listRecentLogs: (serviceName) => run("listRecentLogs", [serviceName]),
+			listTraceLogs: (traceId) => run("listTraceLogs", [traceId]),
+			searchAiCalls: (input) => run("searchAiCalls", [input]),
+			getAiCall: (spanId) => run("getAiCall", [spanId]),
+			aiCallStats: (input) => run("aiCallStats", [input]),
+		})
+	}),
+)