otelly 0.1.0

package/dist/server.js

@@ -0,0 +1,676 @@
+import path from "node:path";
+import { serve } from "@hono/node-server";
+import { HttpApi, HttpApiBuilder, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, HttpServer, OpenApi } from "@effect/platform";
+import { Context, Data, Effect, Layer, ManagedRuntime, Ref, Schema } from "effect";
+import { serveStatic } from "@hono/node-server/serve-static";
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+import Database from "better-sqlite3";
+import { Pool } from "pg";
+import { drizzle } from "drizzle-orm/node-postgres";
+import { bigint, index, integer, jsonb, pgTable, primaryKey, text } from "drizzle-orm/pg-core";
+import { and, desc, eq, sql } from "drizzle-orm";
+
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __exportAll = (all, symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
+//#region ../../packages/core/src/spans/schema/span.model.ts
+const hex = (length) => Schema.String.pipe(Schema.pattern(/* @__PURE__ */ new RegExp(`^[0-9a-fA-F]{${length}}$`), { message: () => `must be a ${length}-character hex string` }));
+const TraceId = hex(32).pipe(Schema.brand("TraceId"));
+const SpanId = hex(16).pipe(Schema.brand("SpanId"));
+const ServiceName = Schema.String.pipe(Schema.minLength(1), Schema.brand("ServiceName"));
+const UnixNano = Schema.String.pipe(Schema.pattern(/^\d+$/, { message: () => "must be a non-negative integer string" }), Schema.brand("UnixNano"));
+const SpanKind = Schema.Literal(0, 1, 2, 3, 4, 5);
+const SpanStatusCode = Schema.Literal(0, 1, 2);
+const AttributeValue = Schema.Union(Schema.String, Schema.Number, Schema.Boolean, Schema.Null, Schema.Array(Schema.Union(Schema.String, Schema.Number, Schema.Boolean, Schema.Null)));
+const Attributes = Schema.Record({
+	key: Schema.String,
+	value: AttributeValue
+});
+const Span = Schema.Struct({
+	traceId: TraceId,
+	spanId: SpanId,
+	parentSpanId: Schema.NullOr(SpanId),
+	serviceName: ServiceName,
+	scopeName: Schema.NullOr(Schema.String),
+	name: Schema.String,
+	kind: Schema.NullOr(SpanKind),
+	startUnixNano: UnixNano,
+	endUnixNano: UnixNano,
+	durationNs: Schema.Number,
+	statusCode: Schema.NullOr(SpanStatusCode),
+	statusMessage: Schema.NullOr(Schema.String),
+	attributes: Attributes,
+	ingestedAt: Schema.Number
+});
+const SpanQuery = Schema.Struct({
+	service: Schema.optional(ServiceName),
+	traceId: Schema.optional(TraceId),
+	limit: Schema.optional(Schema.Number.pipe(Schema.int(), Schema.between(1, 1e3)))
+});
+
+//#endregion
+//#region ../../packages/core/src/spans/schema/span.errors.ts
+var SpanStorageError = class extends Data.TaggedError("SpanStorageError") {};
+var SpanIngestError = class extends Data.TaggedError("SpanIngestError") {};
+
+//#endregion
+//#region ../../packages/core/src/spans/repository/span.repository.ts
+var SpanRepository = class extends Context.Tag("SpanRepository")() {};
+
+//#endregion
+//#region ../../packages/core/src/spans/service/span.service.ts
+var Spans = class extends Effect.Service()("Spans", {
+	accessors: true,
+	effect: Effect.gen(function* () {
+		const repo = yield* SpanRepository;
+		const ingest = (spans$1) => repo.insertMany(spans$1).pipe(Effect.withSpan("Spans.ingest", { attributes: { "spans.count": spans$1.length } }));
+		const byTraceId = (id) => repo.findByTraceId(id).pipe(Effect.withSpan("Spans.byTraceId", { attributes: { "trace.id": id } }));
+		const search = (query) => repo.search(query).pipe(Effect.withSpan("Spans.search"));
+		const recent = (limit = 100) => repo.recent(limit).pipe(Effect.withSpan("Spans.recent", { attributes: { "spans.limit": limit } }));
+		return {
+			ingest,
+			byTraceId,
+			search,
+			recent
+		};
+	})
+}) {};
+
+//#endregion
+//#region ../../packages/core/src/blobs/schema/blob.model.ts
+const BlobKey = Schema.String.pipe(Schema.minLength(1), Schema.maxLength(512), Schema.brand("BlobKey"));
+const BlobRef = Schema.Struct({
+	key: BlobKey,
+	size: Schema.Number,
+	contentType: Schema.NullOr(Schema.String)
+});
+
+//#endregion
+//#region ../../packages/core/src/blobs/schema/blob.errors.ts
+var BlobNotFound = class extends Data.TaggedError("BlobNotFound") {};
+
+//#endregion
+//#region ../../packages/core/src/blobs/storage/blob.storage.ts
+var BlobStorage = class extends Context.Tag("BlobStorage")() {};
+
+//#endregion
+//#region ../../packages/core/src/blobs/storage/blob.storage.memory.ts
+const createMemoryBlobStore = () => Effect.gen(function* () {
+	const ref = yield* Ref.make(/* @__PURE__ */ new Map());
+	const put = (key, body, contentType) => Ref.update(ref, (m) => {
+		const next = new Map(m);
+		next.set(key, {
+			body,
+			contentType: contentType ?? null
+		});
+		return next;
+	}).pipe(Effect.map(() => ({
+		key,
+		size: body.byteLength,
+		contentType: contentType ?? null
+	})));
+	const get = (key) => Effect.gen(function* () {
+		const entry = (yield* Ref.get(ref)).get(key);
+		if (!entry) return yield* Effect.fail(new BlobNotFound({ key }));
+		return entry.body;
+	});
+	const head = (key) => Effect.gen(function* () {
+		const entry = (yield* Ref.get(ref)).get(key);
+		if (!entry) return yield* Effect.fail(new BlobNotFound({ key }));
+		return {
+			key,
+			size: entry.body.byteLength,
+			contentType: entry.contentType
+		};
+	});
+	const remove = (key) => Ref.update(ref, (m) => {
+		if (!m.has(key)) return m;
+		const next = new Map(m);
+		next.delete(key);
+		return next;
+	});
+	return {
+		put,
+		get,
+		head,
+		delete: remove
+	};
+});
+
+//#endregion
+//#region ../../packages/core/src/blobs/layer/blob.layer.ts
+const BlobStorageMemory = Layer.effect(BlobStorage, createMemoryBlobStore());
+
+//#endregion
+//#region ../../packages/api/src/spans/spans.api.ts
+const TraceIdParam = Schema.Struct({ id: TraceId });
+const RecentParams = Schema.Struct({ limit: Schema.optional(Schema.NumberFromString.pipe(Schema.int(), Schema.between(1, 1e3))) });
+var TraceNotFound = class extends Schema.TaggedError()("TraceNotFound", { id: TraceId }, HttpApiSchema.annotations({ status: 404 })) {};
+var SpansApi = class extends HttpApiGroup.make("spans").add(HttpApiEndpoint.get("recent", "/spans").setUrlParams(RecentParams).addSuccess(Schema.Array(Span))).add(HttpApiEndpoint.get("byTraceId", "/traces/:id").setPath(TraceIdParam).addSuccess(Schema.Array(Span)).addError(TraceNotFound)) {};
+
+//#endregion
+//#region ../../packages/api/src/api.ts
+var Api = class extends HttpApi.make("otelly").add(SpansApi).prefix("/api") {};
+
+//#endregion
+//#region ../../packages/storage-sqlite/src/db.ts
+const SCHEMA_SQL$1 = `
+  CREATE TABLE IF NOT EXISTS spans (
+    trace_id          TEXT NOT NULL,
+    span_id           TEXT NOT NULL,
+    parent_span_id    TEXT,
+    service_name      TEXT NOT NULL,
+    scope_name        TEXT,
+    name              TEXT NOT NULL,
+    kind              INTEGER,
+    start_unix_nano   TEXT NOT NULL,
+    end_unix_nano     TEXT NOT NULL,
+    duration_ns       INTEGER NOT NULL,
+    status_code       INTEGER,
+    status_message    TEXT,
+    attributes_json   TEXT,
+    ingested_at       INTEGER NOT NULL,
+    PRIMARY KEY (trace_id, span_id)
+  );
+  CREATE INDEX IF NOT EXISTS spans_ingested_at_idx ON spans (ingested_at DESC);
+  CREATE INDEX IF NOT EXISTS spans_service_idx     ON spans (service_name, ingested_at DESC);
+  CREATE INDEX IF NOT EXISTS spans_trace_idx       ON spans (trace_id);
+`;
+const openSqlite = (path$1) => {
+	const handle = new Database(path$1);
+	handle.pragma("journal_mode = WAL");
+	handle.pragma("synchronous = NORMAL");
+	handle.exec(SCHEMA_SQL$1);
+	return handle;
+};
+
+//#endregion
+//#region ../../packages/storage-sqlite/src/effect.ts
+const SQLITE_SPAN_ATTRS = { "db.system": "sqlite" };
+const trySqlite = (op, run) => Effect.try({
+	try: run,
+	catch: (cause) => new SpanStorageError({
+		op,
+		cause
+	})
+}).pipe(Effect.tapErrorTag("SpanStorageError", (e) => Effect.logError(`sqlite ${e.op} failed`, e.cause)), Effect.orDie, Effect.withSpan(op, { attributes: SQLITE_SPAN_ATTRS }));
+
+//#endregion
+//#region ../../packages/storage-sqlite/src/spans/span.repository.sqlite.ts
+const decodeRow = Schema.decodeUnknownSync(Span);
+const rowToSpan$1 = (row) => decodeRow({
+	traceId: row.trace_id,
+	spanId: row.span_id,
+	parentSpanId: row.parent_span_id,
+	serviceName: row.service_name,
+	scopeName: row.scope_name,
+	name: row.name,
+	kind: row.kind,
+	startUnixNano: row.start_unix_nano,
+	endUnixNano: row.end_unix_nano,
+	durationNs: row.duration_ns,
+	statusCode: row.status_code,
+	statusMessage: row.status_message,
+	attributes: row.attributes_json ? JSON.parse(row.attributes_json) : {},
+	ingestedAt: row.ingested_at
+});
+const spanToRow$1 = (s) => ({
+	trace_id: s.traceId,
+	span_id: s.spanId,
+	parent_span_id: s.parentSpanId,
+	service_name: s.serviceName,
+	scope_name: s.scopeName,
+	name: s.name,
+	kind: s.kind,
+	start_unix_nano: s.startUnixNano,
+	end_unix_nano: s.endUnixNano,
+	duration_ns: s.durationNs,
+	status_code: s.statusCode,
+	status_message: s.statusMessage,
+	attributes_json: JSON.stringify(s.attributes),
+	ingested_at: s.ingestedAt
+});
+const createSqliteSpanRepo = (handle) => {
+	const insertStmt = handle.prepare(`
+    INSERT OR REPLACE INTO spans
+      (trace_id, span_id, parent_span_id, service_name, scope_name, name, kind,
+       start_unix_nano, end_unix_nano, duration_ns, status_code, status_message,
+       attributes_json, ingested_at)
+    VALUES (@trace_id, @span_id, @parent_span_id, @service_name, @scope_name, @name, @kind,
+            @start_unix_nano, @end_unix_nano, @duration_ns, @status_code, @status_message,
+            @attributes_json, @ingested_at)
+  `);
+	const insertTx = handle.transaction((rows) => {
+		for (const row of rows) insertStmt.run(row);
+	});
+	const byTraceStmt = handle.prepare(`
+    SELECT * FROM spans WHERE trace_id = ? ORDER BY start_unix_nano ASC
+  `);
+	const recentStmt = handle.prepare(`
+    SELECT * FROM spans ORDER BY ingested_at DESC LIMIT ?
+  `);
+	return {
+		insertMany: (spans$1) => trySqlite("sqlite.spans.insertMany", () => {
+			if (spans$1.length === 0) return 0;
+			insertTx(spans$1.map(spanToRow$1));
+			return spans$1.length;
+		}),
+		findByTraceId: (id) => trySqlite("sqlite.spans.findByTraceId", () => byTraceStmt.all(id)).pipe(Effect.map((rows) => rows.map(rowToSpan$1))),
+		search: (query) => trySqlite("sqlite.spans.search", () => {
+			const limit = query.limit ?? 100;
+			const where = [];
+			const params = [];
+			if (query.service !== void 0) {
+				where.push("service_name = ?");
+				params.push(query.service);
+			}
+			if (query.traceId !== void 0) {
+				where.push("trace_id = ?");
+				params.push(query.traceId);
+			}
+			const sql$1 = `
+          SELECT * FROM spans
+          ${where.length > 0 ? `WHERE ${where.join(" AND ")}` : ""}
+          ORDER BY ingested_at DESC
+          LIMIT ?
+        `;
+			params.push(limit);
+			return handle.prepare(sql$1).all(...params);
+		}).pipe(Effect.map((rows) => rows.map(rowToSpan$1))),
+		recent: (limit) => trySqlite("sqlite.spans.recent", () => recentStmt.all(limit)).pipe(Effect.map((rows) => rows.map(rowToSpan$1)))
+	};
+};
+
+//#endregion
+//#region ../../packages/storage-pg/src/schema.ts
+var schema_exports = /* @__PURE__ */ __exportAll({ spans: () => spans });
+const spans = pgTable("spans", {
+	traceId: text("trace_id").notNull(),
+	spanId: text("span_id").notNull(),
+	parentSpanId: text("parent_span_id"),
+	serviceName: text("service_name").notNull(),
+	scopeName: text("scope_name"),
+	name: text("name").notNull(),
+	kind: integer("kind"),
+	startUnixNano: text("start_unix_nano").notNull(),
+	endUnixNano: text("end_unix_nano").notNull(),
+	durationNs: bigint("duration_ns", { mode: "number" }).notNull(),
+	statusCode: integer("status_code"),
+	statusMessage: text("status_message"),
+	attributes: jsonb("attributes").$type().notNull(),
+	ingestedAt: bigint("ingested_at", { mode: "number" }).notNull()
+}, (t) => [
+	primaryKey({ columns: [t.traceId, t.spanId] }),
+	index("spans_ingested_at_idx").on(sql`${t.ingestedAt} DESC`),
+	index("spans_service_idx").on(t.serviceName, sql`${t.ingestedAt} DESC`),
+	index("spans_trace_idx").on(t.traceId)
+]);
+
+//#endregion
+//#region ../../packages/storage-pg/src/db.ts
+const SCHEMA_SQL = `
+  CREATE TABLE IF NOT EXISTS spans (
+    trace_id        TEXT NOT NULL,
+    span_id         TEXT NOT NULL,
+    parent_span_id  TEXT,
+    service_name    TEXT NOT NULL,
+    scope_name      TEXT,
+    name            TEXT NOT NULL,
+    kind            INTEGER,
+    start_unix_nano TEXT NOT NULL,
+    end_unix_nano   TEXT NOT NULL,
+    duration_ns     BIGINT NOT NULL,
+    status_code     INTEGER,
+    status_message  TEXT,
+    attributes      JSONB NOT NULL DEFAULT '{}'::jsonb,
+    ingested_at     BIGINT NOT NULL,
+    PRIMARY KEY (trace_id, span_id)
+  );
+  CREATE INDEX IF NOT EXISTS spans_ingested_at_idx ON spans (ingested_at DESC);
+  CREATE INDEX IF NOT EXISTS spans_service_idx     ON spans (service_name, ingested_at DESC);
+  CREATE INDEX IF NOT EXISTS spans_trace_idx       ON spans (trace_id);
+`;
+const openPostgres = async (databaseUrl) => {
+	const pool = new Pool({ connectionString: databaseUrl });
+	const client = await pool.connect();
+	try {
+		await client.query(SCHEMA_SQL);
+	} finally {
+		client.release();
+	}
+	return {
+		pool,
+		db: drizzle(pool, { schema: schema_exports })
+	};
+};
+const closePostgres = (handle) => handle.pool.end();
+
+//#endregion
+//#region ../../packages/storage-pg/src/effect.ts
+var PostgresError = class extends Data.TaggedError("PostgresError") {};
+const PG_SPAN_ATTRS = { "db.system": "postgresql" };
+const tryDb = (op, run) => Effect.tryPromise({
+	try: run,
+	catch: (cause) => new PostgresError({
+		op,
+		cause
+	})
+}).pipe(Effect.tapErrorTag("PostgresError", (e) => Effect.logError(`postgres ${e.op} failed`, e.cause)), Effect.orDie, Effect.withSpan(op, { attributes: PG_SPAN_ATTRS }));
+
+//#endregion
+//#region ../../packages/storage-pg/src/spans/span.repository.pg.ts
+const decodeSpan = Schema.decodeUnknownSync(Span);
+const rowToSpan = (row) => decodeSpan({
+	traceId: row.traceId,
+	spanId: row.spanId,
+	parentSpanId: row.parentSpanId,
+	serviceName: row.serviceName,
+	scopeName: row.scopeName,
+	name: row.name,
+	kind: row.kind,
+	startUnixNano: row.startUnixNano,
+	endUnixNano: row.endUnixNano,
+	durationNs: row.durationNs,
+	statusCode: row.statusCode,
+	statusMessage: row.statusMessage,
+	attributes: row.attributes ?? {},
+	ingestedAt: row.ingestedAt
+});
+const spanToRow = (s) => ({
+	traceId: s.traceId,
+	spanId: s.spanId,
+	parentSpanId: s.parentSpanId,
+	serviceName: s.serviceName,
+	scopeName: s.scopeName,
+	name: s.name,
+	kind: s.kind,
+	startUnixNano: s.startUnixNano,
+	endUnixNano: s.endUnixNano,
+	durationNs: s.durationNs,
+	statusCode: s.statusCode,
+	statusMessage: s.statusMessage,
+	attributes: s.attributes,
+	ingestedAt: s.ingestedAt
+});
+const createPostgresSpanRepo = (db) => ({
+	insertMany: (toInsert) => tryDb("pg.spans.insertMany", async () => {
+		if (toInsert.length === 0) return 0;
+		const rows = toInsert.map(spanToRow);
+		await db.insert(spans).values(rows).onConflictDoUpdate({
+			target: [spans.traceId, spans.spanId],
+			set: {
+				parentSpanId: sql`excluded.parent_span_id`,
+				serviceName: sql`excluded.service_name`,
+				scopeName: sql`excluded.scope_name`,
+				name: sql`excluded.name`,
+				kind: sql`excluded.kind`,
+				startUnixNano: sql`excluded.start_unix_nano`,
+				endUnixNano: sql`excluded.end_unix_nano`,
+				durationNs: sql`excluded.duration_ns`,
+				statusCode: sql`excluded.status_code`,
+				statusMessage: sql`excluded.status_message`,
+				attributes: sql`excluded.attributes`,
+				ingestedAt: sql`excluded.ingested_at`
+			}
+		});
+		return toInsert.length;
+	}),
+	findByTraceId: (id) => tryDb("pg.spans.findByTraceId", () => db.select().from(spans).where(eq(spans.traceId, id))).pipe(Effect.map((rows) => rows.map(rowToSpan))),
+	search: (query) => tryDb("pg.spans.search", () => {
+		const limit = query.limit ?? 100;
+		const where = [query.service !== void 0 ? eq(spans.serviceName, query.service) : void 0, query.traceId !== void 0 ? eq(spans.traceId, query.traceId) : void 0].filter((c) => c !== void 0);
+		const condition = where.length > 0 ? and(...where) : void 0;
+		const base = db.select().from(spans);
+		return (condition !== void 0 ? base.where(condition) : base).orderBy(desc(spans.ingestedAt)).limit(limit);
+	}).pipe(Effect.map((rows) => rows.map(rowToSpan))),
+	recent: (limit) => tryDb("pg.spans.recent", () => db.select().from(spans).orderBy(desc(spans.ingestedAt)).limit(limit)).pipe(Effect.map((rows) => rows.map(rowToSpan)))
+});
+
+//#endregion
+//#region ../server/src/runtime.ts
+const readMode = () => process.env.OTELLY_MODE === "server" ? "server" : "embedded";
+const requireEnv = (name) => {
+	const v = process.env[name];
+	if (!v || v.length === 0) throw new Error(`${name} env var is required in server mode`);
+	return v;
+};
+const resolveSqlitePath = () => {
+	const fromEnv = process.env.OTELLY_DB;
+	if (fromEnv && fromEnv.length > 0) return fromEnv;
+	return path.resolve(process.cwd(), "otelly.sqlite");
+};
+const buildEmbedded = () => {
+	const dbPath = resolveSqlitePath();
+	const sqliteHandle = openSqlite(dbPath);
+	const spanRepo = createSqliteSpanRepo(sqliteHandle);
+	return {
+		mode: "embedded",
+		displayPrimary: `sqlite=${dbPath}`,
+		spanRepo,
+		shutdown: async () => {
+			sqliteHandle.close();
+		}
+	};
+};
+const buildServer = async () => {
+	const databaseUrl = requireEnv("DATABASE_URL");
+	const pgHandle = await openPostgres(databaseUrl);
+	const spanRepo = createPostgresSpanRepo(pgHandle.db);
+	return {
+		mode: "server",
+		displayPrimary: `postgres=${databaseUrl.replace(/:[^@]+@/, ":***@")}`,
+		spanRepo,
+		shutdown: async () => closePostgres(pgHandle)
+	};
+};
+const resolved = readMode() === "server" ? await buildServer() : buildEmbedded();
+process.on("exit", () => {
+	resolved.shutdown();
+});
+const propagate = (signal) => () => {
+	resolved.shutdown().finally(() => process.kill(process.pid, signal));
+};
+process.once("SIGINT", propagate("SIGINT"));
+process.once("SIGTERM", propagate("SIGTERM"));
+const SpanRepoLive = Layer.succeed(SpanRepository, resolved.spanRepo);
+const ServicesLive = Spans.Default.pipe(Layer.provide(SpanRepoLive));
+const config = {
+	mode: resolved.mode,
+	primary: resolved.displayPrimary
+};
+
+//#endregion
+//#region ../server/src/features/spans/spans.handlers.ts
+const SpanHandlersLive = HttpApiBuilder.group(Api, "spans", (handlers) => handlers.handle("recent", ({ urlParams }) => Spans.recent(urlParams.limit ?? 100).pipe(Effect.map((arr) => [...arr]))).handle("byTraceId", ({ path: path$1 }) => Effect.gen(function* () {
+	const spans$1 = yield* Spans.byTraceId(path$1.id);
+	if (spans$1.length === 0) return yield* Effect.fail(new TraceNotFound({ id: path$1.id }));
+	return [...spans$1];
+})));
+const SpanHandlers = SpanHandlersLive.pipe(Layer.provide(ServicesLive));
+
+//#endregion
+//#region ../../packages/ingest/src/otlp/attributes.ts
+const toPrimitive = (v) => {
+	if (!v) return null;
+	if (typeof v.stringValue === "string") return v.stringValue;
+	if (typeof v.boolValue === "boolean") return v.boolValue;
+	if (typeof v.intValue !== "undefined") {
+		const n = typeof v.intValue === "number" ? v.intValue : Number(v.intValue);
+		return Number.isFinite(n) ? n : String(v.intValue);
+	}
+	if (typeof v.doubleValue === "number") return v.doubleValue;
+	if (typeof v.bytesValue === "string") return v.bytesValue;
+	return null;
+};
+const toValue = (v) => {
+	if (v?.arrayValue) return (v.arrayValue.values ?? []).map(toPrimitive);
+	return toPrimitive(v);
+};
+const flattenAttributes = (attrs) => {
+	const out = {};
+	if (!attrs) return out;
+	for (const kv of attrs) {
+		if (!kv.key) continue;
+		out[kv.key] = toValue(kv.value);
+	}
+	return out;
+};
+const findAttr = (attrs, key) => {
+	if (!attrs) return null;
+	const v = attrs.find((kv) => kv.key === key)?.value;
+	if (!v) return null;
+	if (typeof v.stringValue === "string") return v.stringValue;
+	if (typeof v.intValue !== "undefined") return String(v.intValue);
+	if (typeof v.doubleValue === "number") return String(v.doubleValue);
+	if (typeof v.boolValue === "boolean") return String(v.boolValue);
+	return null;
+};
+
+//#endregion
+//#region ../../packages/ingest/src/otlp/traces.ts
+const HEX_RE = /^[0-9a-f]+$/;
+const normalizeHex = (raw, length) => {
+	if (!raw) return null;
+	const lower = raw.toLowerCase();
+	if (lower.length !== length) return null;
+	if (!HEX_RE.test(lower)) return null;
+	return lower;
+};
+const toUnixNano = (raw) => {
+	if (raw === void 0 || raw === null) return null;
+	const s = typeof raw === "number" ? Math.trunc(raw).toString() : raw;
+	if (!/^\d+$/.test(s)) return null;
+	return s;
+};
+const buildRow = (rs, serviceName, scopeName, span, ingestedAt) => {
+	const traceId = normalizeHex(span.traceId, 32);
+	const spanId = normalizeHex(span.spanId, 16);
+	if (!traceId || !spanId) return null;
+	const startNs = toUnixNano(span.startTimeUnixNano);
+	const endNs = toUnixNano(span.endTimeUnixNano);
+	if (!startNs || !endNs) return null;
+	const parentSpanId = normalizeHex(span.parentSpanId, 16);
+	const durationNs = Number(BigInt(endNs) - BigInt(startNs));
+	const spanAttrs = flattenAttributes(span.attributes);
+	const attributes = {
+		...flattenAttributes(rs.resource?.attributes),
+		...spanAttrs
+	};
+	return {
+		traceId,
+		spanId,
+		parentSpanId,
+		serviceName,
+		scopeName,
+		name: span.name ?? "",
+		kind: typeof span.kind === "number" ? span.kind : null,
+		startUnixNano: startNs,
+		endUnixNano: endNs,
+		durationNs,
+		statusCode: typeof span.status?.code === "number" ? span.status.code : null,
+		statusMessage: span.status?.message ?? null,
+		attributes,
+		ingestedAt
+	};
+};
+const decodeTraceRequest = (body, now = Date.now()) => Effect.gen(function* () {
+	const candidates = [];
+	let skipped = 0;
+	for (const rs of body.resourceSpans ?? []) {
+		const serviceName = findAttr(rs.resource?.attributes, "service.name") ?? "unknown";
+		for (const ss of rs.scopeSpans ?? []) {
+			const scopeName = ss.scope?.name ?? null;
+			for (const span of ss.spans ?? []) {
+				const row = buildRow(rs, serviceName, scopeName, span, now);
+				if (row === null) {
+					skipped += 1;
+					continue;
+				}
+				candidates.push(row);
+			}
+		}
+	}
+	return {
+		spans: yield* Schema.decodeUnknown(Schema.Array(Span))(candidates).pipe(Effect.mapError((cause) => new SpanIngestError({
+			reason: "schema decode failed for trace batch",
+			cause
+		}))),
+		skipped
+	};
+}).pipe(Effect.withSpan("Ingest.decodeTraceRequest"));
+
+//#endregion
+//#region ../server/src/features/spans/spans.ingest.ts
+const mountIngest = (app$1, runtime$1) => {
+	app$1.post("/v1/traces", async (c) => {
+		let body;
+		try {
+			body = await c.req.json();
+		} catch {
+			return c.json({ error: "invalid JSON" }, 400);
+		}
+		const program = Effect.gen(function* () {
+			const { spans: spans$1, skipped } = yield* decodeTraceRequest(body);
+			return {
+				insertedSpans: yield* Spans.ingest(spans$1),
+				skippedSpans: skipped
+			};
+		});
+		const exit = await runtime$1.runPromiseExit(program);
+		if (exit._tag === "Failure") return c.json({
+			error: "ingest failed",
+			cause: String(exit.cause)
+		}, 500);
+		return c.json(exit.value);
+	});
+};
+
+//#endregion
+//#region ../server/src/server.ts
+const ApiLive = HttpApiBuilder.api(Api).pipe(Layer.provide(SpanHandlers));
+const ApiLayer = Layer.mergeAll(ApiLive, HttpApiBuilder.Router.Live, HttpServer.layerContext);
+const { handler: apiHandler } = HttpApiBuilder.toWebHandler(ApiLayer);
+const spec = OpenApi.fromApi(Api);
+const runtime = ManagedRuntime.make(ServicesLive);
+const staticDir = process.env.OTELLY_STATIC_DIR;
+const app = new Hono().use("*", cors({
+	origin: (o) => o ?? "*",
+	credentials: true
+})).get("/health", (c) => c.json({
+	ok: true,
+	mode: config.mode,
+	primary: config.primary
+})).get("/openapi", (c) => c.json(spec)).all("/api/*", (c) => apiHandler(c.req.raw));
+mountIngest(app, runtime);
+if (staticDir !== void 0 && staticDir.length > 0) app.use("/*", serveStatic({
+	root: staticDir,
+	rewriteRequestPath: (path$1) => path$1 === "/" ? "/index.html" : path$1
+}));
+
+//#endregion
+//#region ../server/src/main.ts
+const port = Number(process.env.PORT ?? 4318);
+serve({
+	fetch: app.fetch,
+	port
+}, (info) => {
+	process.stdout.write(`otelly-server · http://localhost:${info.port} · mode=${config.mode} · ${config.primary}\n`);
+});
+
+//#endregion
+export {  };