@fml-inc/fml 0.7.0 → 0.8.0-rc.2

package/dist/observer-server.js

@@ -0,0 +1,1566 @@
+#!/usr/bin/env node
+import {
+  ObserverStateMutationBusyError,
+  claimObserverState,
+  createInitialObserverState,
+  observerLeaseIsOwned,
+  removeObserverStateIfOwned,
+  updateObserverState
+} from "./chunk-WZLLO563.js";
+import {
+  createHookSyncLoop,
+  getActiveHookDestinationBinding
+} from "./chunk-DZKYW327.js";
+import {
+  OBSERVER_PROTOCOL_VERSION,
+  OBSERVER_SERVICE_NAME,
+  ObserverHookSpoolEntryTooLargeError,
+  acknowledgeHookInboxEntry,
+  createObserverHttpServer,
+  drainHookInbox,
+  getOrCreateObserverAuthToken,
+  normalizeObserverHookCapture,
+  openObserverDatabase,
+  parseHookCaptureRequest,
+  parseHookInboxMetadata,
+  readHookInboxStatusAsync,
+  retireHookInboxEntry
+} from "./chunk-56TPYMNK.js";
+import "./chunk-7V7G7NVF.js";
+import {
+  ObserverSyncCycleAbortedError,
+  runObserverSyncCycleSubprocess
+} from "./chunk-3KISRT57.js";
+import {
+  createCliRawSync
+} from "./chunk-YSU5CS2V.js";
+import {
+  FML_OBSERVER_AUTH_TOKEN_FILE,
+  FML_OBSERVER_ENDPOINT_FILE,
+  FML_OBSERVER_HOST,
+  FML_OBSERVER_LOCK_FILE,
+  FML_OBSERVER_PORT,
+  FML_OBSERVER_STATE_FILE,
+  FML_PANOPTICON_DB_FILE,
+  FML_PANOPTICON_DB_OBSERVER_LOCK_FILE,
+  FML_PANOPTICON_DB_OBSERVER_STATE_FILE,
+  ensureDirs,
+  getActiveEnv,
+  getSiteUrlForConvexUrl,
+  getSyncDestinationAuthBinding,
+  getValidToken,
+  observerOnlyOverrideWarning
+} from "./chunk-A6HAEVJX.js";
+import "./chunk-MLKGABMK.js";
+
+// src/observer-server.ts
+import fs from "fs";
+
+// src/otel/sync-loop.ts
+import { createHash } from "crypto";
+var IDLE_INTERVAL_MS = 3e4;
+var AUTH_INTERVAL_MS = 6e4;
+var MIN_RETRY_INTERVAL_MS = 2e3;
+var MAX_RETRY_INTERVAL_MS = 5 * 6e4;
+var MAX_RETRY_AFTER_MS = 24 * 60 * 6e4;
+var OTLP_UPLOAD_TIMEOUT_MS = 45e3;
+var MAX_ERROR_TEXT_BYTES = 1e3;
+var MAX_REJECTION_REASON_BYTES = 3 * 1024;
+var MAX_OTLP_RESPONSE_BYTES = 64 * 1024;
+var MAX_OTLP_UPLOAD_ATTEMPTS = 10;
+var MAX_OTLP_RETRY_AGE_MS = 24 * 60 * 6e4;
+var OUTBOX_BATCH_SIZE = 1;
+var DRAIN_INTERVAL_MS = 25;
+function combineWarnings(...warnings) {
+  const present = warnings.filter(
+    (warning) => warning !== void 0
+  );
+  return present.length === 0 ? void 0 : boundedUtf8(present.join("; "), MAX_ERROR_TEXT_BYTES);
+}
+function utf8Prefix(value, maxBytes) {
+  let low = 0;
+  let high = value.length;
+  while (low < high) {
+    const middle = Math.ceil((low + high) / 2);
+    if (Buffer.byteLength(value.slice(0, middle), "utf8") <= maxBytes) {
+      low = middle;
+    } else {
+      high = middle - 1;
+    }
+  }
+  let end = low;
+  if (end > 0 && end < value.length && value.charCodeAt(end - 1) >= 55296 && value.charCodeAt(end - 1) <= 56319 && value.charCodeAt(end) >= 56320 && value.charCodeAt(end) <= 57343) {
+    end -= 1;
+  }
+  return value.slice(0, end);
+}
+function boundedUtf8(value, maxBytes) {
+  if (Buffer.byteLength(value, "utf8") <= maxBytes) return value;
+  const marker = "...";
+  return `${utf8Prefix(value, maxBytes - marker.length)}${marker}`;
+}
+function dropReason(prefix, detail) {
+  return boundedUtf8(`${prefix}: ${detail}`, MAX_REJECTION_REASON_BYTES);
+}
+function retryAtMs(response, nowMs) {
+  const value = response.headers.get("Retry-After");
+  if (!value) return void 0;
+  const seconds = Number(value);
+  const candidate = Number.isFinite(seconds) ? nowMs + Math.max(0, seconds) * 1e3 : Date.parse(value);
+  if (!Number.isFinite(candidate)) return void 0;
+  return Math.min(nowMs + MAX_RETRY_AFTER_MS, Math.max(nowMs, candidate));
+}
+function bodySha256(body) {
+  return createHash("sha256").update(body).digest("hex");
+}
+function parseVarint(body, offset) {
+  let value = 0n;
+  for (let index = 0; index < 10 && offset + index < body.length; index += 1) {
+    const byte = body[offset + index];
+    if (index === 9 && byte > 1) return null;
+    value |= BigInt(byte & 127) << BigInt(index * 7);
+    if ((byte & 128) === 0) {
+      return { value, nextOffset: offset + index + 1 };
+    }
+  }
+  return null;
+}
+function parseLengthDelimited(body, offset) {
+  const length = parseVarint(body, offset);
+  if (!length || length.value > BigInt(Number.MAX_SAFE_INTEGER)) return null;
+  const byteLength = Number(length.value);
+  const end = length.nextOffset + byteLength;
+  if (end > body.length) return null;
+  return { value: body.subarray(length.nextOffset, end), nextOffset: end };
+}
+function validateProtobufPartialSuccess(body) {
+  let offset = 0;
+  let rejectedRecords = 0n;
+  let warning;
+  while (offset < body.length) {
+    const key = parseVarint(body, offset);
+    if (!key) {
+      return { error: "OTLP partial-success response has a malformed field" };
+    }
+    offset = key.nextOffset;
+    const fieldNumber = key.value >> 3n;
+    const wireType = Number(key.value & 0x07n);
+    if (fieldNumber === 1n && wireType === 0) {
+      const rejected = parseVarint(body, offset);
+      if (!rejected) {
+        return {
+          error: "OTLP partial-success response has a malformed rejected count"
+        };
+      }
+      offset = rejected.nextOffset;
+      if (rejected.value > rejectedRecords) rejectedRecords = rejected.value;
+      continue;
+    }
+    if (fieldNumber === 2n && wireType === 2) {
+      const errorMessage = parseLengthDelimited(body, offset);
+      if (!errorMessage) {
+        return {
+          error: "OTLP partial-success response has a malformed error message"
+        };
+      }
+      offset = errorMessage.nextOffset;
+      let decoded;
+      try {
+        decoded = new TextDecoder("utf-8", { fatal: true }).decode(
+          errorMessage.value
+        );
+      } catch {
+        return {
+          error: "OTLP partial-success response has a non-UTF-8 error message"
+        };
+      }
+      if (decoded.length > 0) {
+        warning = boundedUtf8(
+          `OTLP destination reported partial success: ${decoded}`,
+          MAX_ERROR_TEXT_BYTES
+        );
+      }
+      continue;
+    }
+    return {
+      error: "OTLP partial-success response contains an unexpected field"
+    };
+  }
+  if (rejectedRecords > 0n) {
+    return {
+      error: `OTLP destination partially rejected ${rejectedRecords.toString()} record(s)`,
+      rejectedRecords
+    };
+  }
+  return warning ? { warning } : {};
+}
+function validateProtobufSuccess(body) {
+  let offset = 0;
+  let warning;
+  while (offset < body.length) {
+    const key = parseVarint(body, offset);
+    if (!key) return { error: "OTLP success response has a malformed field" };
+    offset = key.nextOffset;
+    const fieldNumber = key.value >> 3n;
+    const wireType = Number(key.value & 0x07n);
+    if (fieldNumber !== 1n || wireType !== 2) {
+      return { error: "OTLP success response contains an unexpected field" };
+    }
+    const partialSuccess = parseLengthDelimited(body, offset);
+    if (!partialSuccess) {
+      return {
+        error: "OTLP success response has a malformed partial-success field"
+      };
+    }
+    offset = partialSuccess.nextOffset;
+    const partial = validateProtobufPartialSuccess(partialSuccess.value);
+    if (partial.error) return partial;
+    if (partial.warning) warning = partial.warning;
+  }
+  return warning ? { warning } : {};
+}
+function rejectedJsonCount(value) {
+  if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0) {
+    return BigInt(value);
+  }
+  if (typeof value === "string" && value.length <= 20 && /^(?:0|[1-9]\d*)$/.test(value)) {
+    return BigInt(value);
+  }
+  return null;
+}
+function validateJsonSuccess(body, signal) {
+  let decoded;
+  try {
+    decoded = new TextDecoder("utf-8", { fatal: true }).decode(body);
+  } catch {
+    return { error: "OTLP JSON success response is not UTF-8" };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(decoded);
+  } catch {
+    return { error: "OTLP JSON success response is malformed" };
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return { error: "OTLP JSON success response is not an object" };
+  }
+  const response = parsed;
+  if (Object.keys(response).some((key) => key !== "partialSuccess")) {
+    return {
+      error: "OTLP JSON success response contains an unexpected field"
+    };
+  }
+  const partialSuccess = response.partialSuccess;
+  if (partialSuccess === void 0) return {};
+  if (!partialSuccess || typeof partialSuccess !== "object" || Array.isArray(partialSuccess)) {
+    return { error: "OTLP JSON partial-success response is not an object" };
+  }
+  const partial = partialSuccess;
+  const rejectedField = signal === "traces" ? "rejectedSpans" : signal === "metrics" ? "rejectedDataPoints" : "rejectedLogRecords";
+  if (Object.keys(partial).some(
+    (key) => key !== rejectedField && key !== "errorMessage"
+  )) {
+    return {
+      error: "OTLP JSON partial-success response contains an unexpected field"
+    };
+  }
+  if (partial[rejectedField] !== void 0) {
+    const rejected = rejectedJsonCount(partial[rejectedField]);
+    if (rejected === null) {
+      return {
+        error: "OTLP JSON partial-success response has an invalid rejected count"
+      };
+    }
+    if (rejected > 0n) {
+      return {
+        error: `OTLP destination partially rejected ${rejected.toString()} record(s)`,
+        rejectedRecords: rejected
+      };
+    }
+  }
+  if (partial.errorMessage !== void 0) {
+    if (typeof partial.errorMessage !== "string") {
+      return {
+        error: "OTLP JSON partial-success response has an invalid error message"
+      };
+    }
+    if (partial.errorMessage.length > 0) {
+      return {
+        warning: boundedUtf8(
+          `OTLP destination reported partial success: ${partial.errorMessage}`,
+          MAX_ERROR_TEXT_BYTES
+        )
+      };
+    }
+  }
+  return {};
+}
+async function readBoundedResponseBytes(response, maxBytes) {
+  const declaredLength = response.headers.get("Content-Length");
+  if (declaredLength !== null && /^\d+$/.test(declaredLength) && Number(declaredLength) > maxBytes) {
+    await response.body?.cancel().catch(() => void 0);
+    return null;
+  }
+  if (!response.body) return new Uint8Array();
+  const reader = response.body.getReader();
+  const chunks = [];
+  let totalBytes = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      totalBytes += value.byteLength;
+      if (totalBytes > maxBytes) {
+        await reader.cancel().catch(() => void 0);
+        return null;
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const body = new Uint8Array(totalBytes);
+  let offset = 0;
+  for (const chunk of chunks) {
+    body.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return body;
+}
+function validateOtlpPayloadSuccess(body, upstreamContentType, envelope) {
+  const responseContentType = upstreamContentType?.split(";", 1)[0]?.trim().toLowerCase();
+  const validationContentType = responseContentType === "application/json" || responseContentType === "application/x-protobuf" ? responseContentType : envelope.contentType;
+  const contentTypeWarning = responseContentType === envelope.contentType ? void 0 : responseContentType === void 0 ? "OTLP success response omitted Content-Type; validated using the request encoding" : responseContentType === validationContentType ? `OTLP success response changed Content-Type to ${validationContentType}` : `OTLP success response used unsupported Content-Type ${responseContentType}; validated using the request encoding`;
+  const validation = body.byteLength === 0 ? {} : validationContentType === "application/x-protobuf" ? validateProtobufSuccess(body) : validateJsonSuccess(body, envelope.signal);
+  const warning = combineWarnings(contentTypeWarning, validation.warning);
+  return {
+    ...validation.error ? { error: validation.error } : {},
+    ...warning ? { warning } : {},
+    ...validation.rejectedRecords !== void 0 ? { rejectedRecords: validation.rejectedRecords } : {}
+  };
+}
+async function inspectOtlpSuccess(response, envelope) {
+  let body;
+  try {
+    body = await readBoundedResponseBytes(response, MAX_OTLP_RESPONSE_BYTES);
+  } catch {
+    return {
+      warning: "OTLP success response could not be read; treating the 2xx status as delivered"
+    };
+  }
+  if (body === null) {
+    return {
+      warning: `OTLP success response exceeds ${MAX_OTLP_RESPONSE_BYTES} bytes; treating the 2xx status as delivered`
+    };
+  }
+  if (body.byteLength === 0) return {};
+  const validation = validateOtlpPayloadSuccess(
+    body,
+    response.headers.get("Content-Type"),
+    envelope
+  );
+  const parseWarning = validation.error ? `${validation.error}; treating the 2xx status as delivered` : void 0;
+  const partialRejectionWarning = validation.rejectedRecords !== void 0 && validation.rejectedRecords > 0n ? `OTLP destination partially rejected ${validation.rejectedRecords.toString()} record(s)` : void 0;
+  const warning = combineWarnings(
+    validation.warning,
+    parseWarning,
+    partialRejectionWarning
+  );
+  return {
+    ...warning ? { warning } : {}
+  };
+}
+async function responseError(response) {
+  let text = "";
+  try {
+    const bytes = await readBoundedResponseBytes(
+      response,
+      MAX_OTLP_RESPONSE_BYTES
+    );
+    if (bytes === null) {
+      return `OTLP error response exceeds ${MAX_OTLP_RESPONSE_BYTES} bytes`;
+    }
+    text = new TextDecoder().decode(bytes);
+  } catch {
+  }
+  if (text) {
+    try {
+      const body = JSON.parse(text);
+      if (body && typeof body === "object" && !Array.isArray(body)) {
+        const record = body;
+        const detail = typeof record.error === "string" ? record.error : typeof record.message === "string" ? record.message : null;
+        if (detail) return boundedUtf8(detail, MAX_ERROR_TEXT_BYTES);
+      }
+    } catch {
+      return boundedUtf8(text, MAX_ERROR_TEXT_BYTES);
+    }
+  }
+  return `OTLP request failed with HTTP ${response.status}`;
+}
+async function postOtlpEnvelope(destination, envelope, opts) {
+  const body = envelope.body;
+  const headers = {
+    Authorization: destination.authorization,
+    "Content-Type": envelope.contentType,
+    "Content-Encoding": envelope.contentEncoding,
+    "User-Agent": `fml/${opts.version}`,
+    "X-Panopticon-Version": envelope.observerVersion,
+    "X-FML-OTLP-Envelope-Id": envelope.envelopeId,
+    "X-FML-OTLP-Body-SHA256": envelope.sha256,
+    "X-FML-OTLP-Captured-At-Ms": String(envelope.capturedAtMs),
+    "X-FML-Observer-Instance-Id": envelope.observerInstanceId,
+    ...destination.organizationId ? { "X-FML-Organization-Id": destination.organizationId } : {},
+    ...destination.organizationSlug ? { "X-FML-Organization": destination.organizationSlug } : {}
+  };
+  const request = opts.fetch ?? fetch;
+  const timeoutSignal = AbortSignal.timeout(OTLP_UPLOAD_TIMEOUT_MS);
+  const signal = opts.signal ? AbortSignal.any([opts.signal, timeoutSignal]) : timeoutSignal;
+  const response = await request(
+    `${destination.targetUrl.replace(/\/+$/, "")}/v1/${envelope.signal}`,
+    {
+      method: "POST",
+      headers,
+      body: body.buffer instanceof ArrayBuffer ? new Uint8Array(body.buffer, body.byteOffset, body.byteLength) : Uint8Array.from(body),
+      signal
+    }
+  );
+  if (response.ok) {
+    const inspection = await inspectOtlpSuccess(response, envelope);
+    return { ok: true, status: response.status, ...inspection };
+  }
+  const error = await responseError(response);
+  const errorCode = response.headers.get("X-FML-OTLP-Error-Code");
+  return {
+    ok: false,
+    status: response.status,
+    error,
+    ...errorCode ? { errorCode } : {},
+    ...response.status === 429 || response.status >= 500 ? { retryAtMs: retryAtMs(response, opts.nowMs()) } : {}
+  };
+}
+function activeOtlpDestinationSnapshot() {
+  const environment = getActiveEnv();
+  const authBinding = getSyncDestinationAuthBinding(environment.name);
+  if (!authBinding) {
+    return { kind: "unauthenticated", environment: environment.name };
+  }
+  const baseBinding = {
+    environment: environment.name,
+    targetUrl: getSiteUrlForConvexUrl(environment.convexUrl),
+    destinationIdentity: authBinding.destinationIdentity
+  };
+  if (authBinding.organizationSelectionRequired) {
+    return { kind: "organization_required", binding: baseBinding };
+  }
+  return {
+    kind: "ready",
+    binding: {
+      ...baseBinding,
+      ...authBinding.organizationId && authBinding.organizationSlug ? {
+        organizationId: authBinding.organizationId,
+        organizationSlug: authBinding.organizationSlug
+      } : {}
+    }
+  };
+}
+function getActiveOtlpDestinationBinding() {
+  const snapshot = activeOtlpDestinationSnapshot();
+  return snapshot.kind === "unauthenticated" ? null : snapshot.binding;
+}
+function sameDestinationBinding(left, right) {
+  return left.environment === right.environment && left.targetUrl === right.targetUrl && left.destinationIdentity === right.destinationIdentity && left.organizationId === right.organizationId && left.organizationSlug === right.organizationSlug;
+}
+async function resolveDestination(forceRefresh = false) {
+  const initial2 = activeOtlpDestinationSnapshot();
+  if (initial2.kind === "unauthenticated") return initial2;
+  if (initial2.kind === "organization_required") {
+    return {
+      kind: "organization_required",
+      environment: initial2.binding.environment
+    };
+  }
+  const destination = initial2.binding;
+  const token = await getValidToken({
+    env: destination.environment,
+    ...forceRefresh ? { forceRefresh: true } : {}
+  });
+  if (!token) {
+    return {
+      kind: "unauthenticated",
+      environment: destination.environment
+    };
+  }
+  const verified = activeOtlpDestinationSnapshot();
+  if (verified.kind !== "ready" || !sameDestinationBinding(destination, verified.binding)) {
+    if (verified.kind === "ready") {
+      return {
+        kind: "unauthenticated",
+        environment: verified.binding.environment
+      };
+    }
+    return verified.kind === "organization_required" ? {
+      kind: "organization_required",
+      environment: verified.binding.environment
+    } : verified;
+  }
+  return {
+    kind: "ready",
+    destination: {
+      ...destination,
+      authorization: token.startsWith("Bearer ") ? token : `Bearer ${token}`
+    }
+  };
+}
+async function runOtlpSyncCycle(opts) {
+  const nowMs = opts.nowMs ?? Date.now;
+  const cycleStartedAtMs = nowMs();
+  const totalPending = opts.database.countPendingOtlpEnvelopes();
+  if (totalPending === 0) {
+    return { kind: "drained", pending: 0, uploaded: 0 };
+  }
+  const destinationResolution = await resolveDestination();
+  if (destinationResolution.kind !== "ready") {
+    return {
+      kind: destinationResolution.kind,
+      environment: destinationResolution.environment,
+      pending: opts.database.countPendingOtlpEnvelopes(),
+      uploaded: 0
+    };
+  }
+  const destination = destinationResolution.destination;
+  const envelopes = opts.database.claimPendingOtlpEnvelopes(
+    destination,
+    OUTBOX_BATCH_SIZE,
+    cycleStartedAtMs
+  );
+  if (envelopes.length === 0) {
+    const nextAttemptAtMs = opts.database.nextPendingOtlpAttemptAtMs(destination);
+    if (nextAttemptAtMs !== void 0) {
+      return {
+        kind: "completed",
+        environment: destination.environment,
+        pending: opts.database.countPendingOtlpEnvelopes(),
+        uploaded: 0,
+        retryAtMs: nextAttemptAtMs
+      };
+    }
+    return {
+      kind: "destination_drained",
+      environment: destination.environment,
+      pending: opts.database.countPendingOtlpEnvelopes(),
+      uploaded: 0
+    };
+  }
+  let uploaded = 0;
+  let dropped = 0;
+  let lastError;
+  let lastWarning;
+  let nextRetryAtMs;
+  const upload = async (uploadDestination, envelope) => {
+    try {
+      return await postOtlpEnvelope(uploadDestination, envelope, {
+        version: opts.version,
+        ...opts.signal ? { signal: opts.signal } : {},
+        ...opts.fetch ? { fetch: opts.fetch } : {},
+        nowMs
+      });
+    } catch (error) {
+      if (opts.signal?.aborted) throw opts.signal.reason;
+      const detail = error instanceof Error ? error.message : String(error);
+      return {
+        ok: false,
+        status: 0,
+        error: boundedUtf8(
+          `OTLP request failed: ${detail}`,
+          MAX_ERROR_TEXT_BYTES
+        )
+      };
+    }
+  };
+  for (const envelope of envelopes) {
+    if (opts.signal?.aborted) throw opts.signal.reason;
+    if (cycleStartedAtMs - envelope.capturedAtMs >= MAX_OTLP_RETRY_AGE_MS) {
+      dropped += opts.database.dropOtlpEnvelopes(
+        destination,
+        [
+          {
+            envelopeId: envelope.envelopeId,
+            reason: dropReason(
+              "otlp_max_age_exceeded",
+              `captured ${cycleStartedAtMs - envelope.capturedAtMs}ms ago`
+            )
+          }
+        ],
+        nowMs()
+      );
+      continue;
+    }
+    const actualSha256 = bodySha256(envelope.body);
+    if (actualSha256 !== envelope.sha256) {
+      dropped += opts.database.dropOtlpEnvelopes(
+        destination,
+        [
+          {
+            envelopeId: envelope.envelopeId,
+            reason: dropReason(
+              "local_body_hash_mismatch",
+              `expected ${envelope.sha256}, received ${actualSha256}`
+            )
+          }
+        ],
+        nowMs()
+      );
+      continue;
+    }
+    let response = await upload(destination, envelope);
+    if (response.status === 401 && response.errorCode !== "UPSTREAM_REJECTED") {
+      const refreshed = await resolveDestination(true);
+      if (refreshed.kind !== "ready" || !sameDestinationBinding(destination, refreshed.destination) || refreshed.destination.authorization === destination.authorization) {
+        return {
+          kind: "unauthenticated",
+          environment: destination.environment,
+          pending: opts.database.countPendingOtlpEnvelopes(),
+          uploaded
+        };
+      }
+      response = await upload(refreshed.destination, envelope);
+    }
+    if (response.ok) {
+      uploaded += opts.database.acknowledgeOtlpEnvelopes(destination, [
+        envelope.envelopeId
+      ]);
+      lastWarning = response.warning;
+      continue;
+    }
+    if (response.status === 401 && response.errorCode !== "UPSTREAM_REJECTED") {
+      return {
+        kind: "unauthenticated",
+        environment: destination.environment,
+        pending: opts.database.countPendingOtlpEnvelopes(),
+        uploaded
+      };
+    }
+    if (response.errorCode === "ORGANIZATION_REQUIRED") {
+      return {
+        kind: "organization_required",
+        environment: destination.environment,
+        pending: opts.database.countPendingOtlpEnvelopes(),
+        uploaded: 0
+      };
+    }
+    const transient = response.status === 0 || response.status === 429 || response.status >= 500;
+    if (!transient) {
+      dropped += opts.database.dropOtlpEnvelopes(
+        destination,
+        [
+          {
+            envelopeId: envelope.envelopeId,
+            reason: dropReason(
+              `otlp_terminal_http_${response.status}`,
+              response.error ?? "request rejected"
+            )
+          }
+        ],
+        nowMs()
+      );
+      continue;
+    }
+    const attempt = envelope.retryCount + 1;
+    if (attempt >= MAX_OTLP_UPLOAD_ATTEMPTS) {
+      dropped += opts.database.dropOtlpEnvelopes(
+        destination,
+        [
+          {
+            envelopeId: envelope.envelopeId,
+            reason: dropReason(
+              "otlp_attempt_limit_exceeded",
+              response.error ?? `request failed with status ${response.status}`
+            )
+          }
+        ],
+        nowMs()
+      );
+      continue;
+    }
+    const failedAtMs = nowMs();
+    const retryDelayMs = Math.min(
+      MAX_RETRY_INTERVAL_MS,
+      MIN_RETRY_INTERVAL_MS * 2 ** Math.min(envelope.retryCount, 8)
+    );
+    const envelopeRetryAtMs = Math.max(
+      failedAtMs + retryDelayMs,
+      response.retryAtMs ?? failedAtMs
+    );
+    opts.database.deferOtlpEnvelopes(
+      destination,
+      [envelope.envelopeId],
+      envelopeRetryAtMs
+    );
+    lastError = response.error ?? "OTLP upload failed";
+    nextRetryAtMs = opts.database.nextPendingOtlpAttemptAtMs(destination) ?? envelopeRetryAtMs;
+    break;
+  }
+  return {
+    kind: "completed",
+    environment: destination.environment,
+    pending: opts.database.countPendingOtlpEnvelopes(),
+    uploaded,
+    ...dropped > 0 ? { dropped } : {},
+    ...lastError ? { error: lastError } : {},
+    ...lastWarning ? { warning: lastWarning } : {},
+    ...nextRetryAtMs ? { retryAtMs: nextRetryAtMs } : {}
+  };
+}
+function createOtlpSyncLoop(opts) {
+  const nowMs = opts.nowMs ?? Date.now;
+  const runOnce = opts.runOnce ?? runOtlpSyncCycle;
+  let stopping = false;
+  let wakePending = false;
+  let wakeWaiter = null;
+  let activeAbort = null;
+  let failures = 0;
+  let status = {
+    phase: "idle",
+    pending: opts.database.countPendingOtlpEnvelopes()
+  };
+  const wake = () => {
+    wakePending = true;
+    wakeWaiter?.();
+  };
+  const wait = async (delayMs) => {
+    if (stopping || wakePending) {
+      wakePending = false;
+      return;
+    }
+    await new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        wakeWaiter = null;
+        resolve();
+      }, delayMs);
+      wakeWaiter = () => {
+        clearTimeout(timer);
+        wakeWaiter = null;
+        wakePending = false;
+        resolve();
+      };
+    });
+  };
+  const done = (async () => {
+    while (!stopping) {
+      const attemptedAtMs = nowMs();
+      status = {
+        ...status,
+        phase: "syncing",
+        pending: opts.database.countPendingOtlpEnvelopes(),
+        lastAttemptAtMs: attemptedAtMs,
+        lastError: void 0,
+        nextAttemptAtMs: void 0
+      };
+      activeAbort = new AbortController();
+      let result;
+      try {
+        result = await runOnce({
+          database: opts.database,
+          version: opts.version,
+          signal: activeAbort.signal,
+          nowMs
+        });
+      } catch (error) {
+        activeAbort = null;
+        if (stopping) break;
+        failures += 1;
+        const delayMs2 = Math.min(
+          MAX_RETRY_INTERVAL_MS,
+          MIN_RETRY_INTERVAL_MS * 2 ** Math.min(failures - 1, 8)
+        );
+        status = {
+          phase: "backing_off",
+          pending: opts.database.countPendingOtlpEnvelopes(),
+          lastAttemptAtMs: attemptedAtMs,
+          lastError: error instanceof Error ? error.message : String(error),
+          ...status.lastWarning ? { lastWarning: status.lastWarning } : {},
+          nextAttemptAtMs: nowMs() + delayMs2
+        };
+        await wait(delayMs2);
+        continue;
+      }
+      activeAbort = null;
+      if (stopping) break;
+      const completedAtMs = nowMs();
+      const succeeded = result.kind === "drained" || result.kind === "destination_drained" || result.uploaded > 0 || result.kind === "completed" && (result.dropped ?? 0) > 0;
+      failures = result.kind === "completed" && result.error ? failures + 1 : 0;
+      const failureDelay = Math.min(
+        MAX_RETRY_INTERVAL_MS,
+        MIN_RETRY_INTERVAL_MS * 2 ** Math.min(Math.max(0, failures - 1), 8)
+      );
+      const delayMs = result.kind === "unauthenticated" || result.kind === "organization_required" ? AUTH_INTERVAL_MS : result.kind === "completed" && result.pending > 0 ? result.retryAtMs ? Math.max(
+        MIN_RETRY_INTERVAL_MS,
+        result.retryAtMs - completedAtMs
+      ) : result.error ? failureDelay : DRAIN_INTERVAL_MS : IDLE_INTERVAL_MS;
+      status = {
+        phase: result.kind === "unauthenticated" ? "waiting_for_auth" : result.kind === "organization_required" ? "waiting_for_org" : result.kind === "completed" && result.error ? "backing_off" : "idle",
+        pending: result.pending,
+        lastAttemptAtMs: attemptedAtMs,
+        ...succeeded ? { lastSuccessAtMs: completedAtMs } : {},
+        ...result.kind === "completed" && result.error ? { lastError: result.error } : result.kind === "unauthenticated" ? { lastError: "FML login required or token rejected" } : result.kind === "organization_required" ? {
+          lastError: "FML organization selection required; run `fml org`"
+        } : {},
+        ...result.kind === "completed" && result.warning ? { lastWarning: result.warning } : status.lastWarning ? { lastWarning: status.lastWarning } : {},
+        nextAttemptAtMs: completedAtMs + delayMs
+      };
+      await wait(delayMs);
+    }
+  })();
+  return {
+    done,
+    wake,
+    stop: () => {
+      if (stopping) return;
+      stopping = true;
+      activeAbort?.abort();
+      wake();
+    },
+    status: () => status
+  };
+}
+
+// src/hooks/spool-config.ts
+var BYTE_SUFFIXES = {
+  b: 1,
+  kib: 1024,
+  mib: 1024 * 1024,
+  gib: 1024 * 1024 * 1024
+};
+var MAX_BYTES_PATTERN = /^([1-9]\d*)(b|kib|mib|gib)?$/i;
+var POSITIVE_INTEGER_PATTERN = /^[1-9]\d*$/;
+var MILLISECONDS_PER_DAY = 24 * 60 * 60 * 1e3;
+var DEFAULT_HOOK_QUARANTINE_MAX_AGE_DAYS = 30;
+function parseHookSpoolMaxBytes(configured) {
+  if (configured === void 0) return void 0;
+  const value = configured.trim();
+  if (value.toLowerCase() === "unbounded") return void 0;
+  const match = MAX_BYTES_PATTERN.exec(value);
+  if (!match) {
+    throw new Error(
+      "FML_HOOK_SPOOL_MAX_BYTES must be `unbounded` or a positive integer optionally followed by B, KiB, MiB, or GiB"
+    );
+  }
+  const quantity = Number(match[1]);
+  const suffix = match[2]?.toLowerCase() ?? "b";
+  const bytes = quantity * BYTE_SUFFIXES[suffix];
+  if (!Number.isSafeInteger(bytes)) {
+    throw new Error("FML_HOOK_SPOOL_MAX_BYTES exceeds the safe integer range");
+  }
+  return bytes;
+}
+function parseHookQuarantineMaxAgeMs(configured) {
+  if (configured === void 0) {
+    return DEFAULT_HOOK_QUARANTINE_MAX_AGE_DAYS * MILLISECONDS_PER_DAY;
+  }
+  const value = configured.trim();
+  if (value.toLowerCase() === "unbounded") return void 0;
+  if (!POSITIVE_INTEGER_PATTERN.test(value)) {
+    throw new Error(
+      "FML_HOOK_QUARANTINE_MAX_AGE_DAYS must be `unbounded` or a positive integer number of days"
+    );
+  }
+  const milliseconds = Number(value) * MILLISECONDS_PER_DAY;
+  if (!Number.isSafeInteger(milliseconds)) {
+    throw new Error(
+      "FML_HOOK_QUARANTINE_MAX_AGE_DAYS exceeds the safe integer range"
+    );
+  }
+  return milliseconds;
+}
+function parseOtlpSpoolMaxBytes(configured) {
+  if (configured === void 0) return void 0;
+  const value = configured.trim();
+  const match = MAX_BYTES_PATTERN.exec(value);
+  if (!match) {
+    throw new Error(
+      "FML_OTLP_SPOOL_MAX_BYTES must be a positive integer optionally followed by B, KiB, MiB, or GiB"
+    );
+  }
+  const quantity = Number(match[1]);
+  const suffix = match[2]?.toLowerCase() ?? "b";
+  const bytes = quantity * BYTE_SUFFIXES[suffix];
+  if (!Number.isSafeInteger(bytes)) {
+    throw new Error("FML_OTLP_SPOOL_MAX_BYTES exceeds the safe integer range");
+  }
+  return bytes;
+}
+
+// src/observer/sync-loop.ts
+var OBSERVER_IDLE_INTERVAL_MS = 3e4;
+var OBSERVER_BUSY_INTERVAL_MS = 2e3;
+var OBSERVER_AUTH_INTERVAL_MS = 6e4;
+var OBSERVER_MAX_TIMER_DELAY_MS = 2147483647;
+function truncateError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.length > 1e3 ? `${message.slice(0, 997)}...` : message;
+}
+function delayForResult(result, nowMs) {
+  if (result.kind === "unauthenticated") return OBSERVER_AUTH_INTERVAL_MS;
+  if (result.kind !== "completed") return OBSERVER_IDLE_INTERVAL_MS;
+  if (result.outcome === "busy" || result.outcome === "pending") {
+    return OBSERVER_BUSY_INTERVAL_MS;
+  }
+  if (result.outcome === "throttled" && result.retryAtMs !== void 0) {
+    return Math.max(1e3, result.retryAtMs - nowMs);
+  }
+  if (result.outcome === "backing_off" && result.nextRetryAtMs !== void 0) {
+    return Math.min(
+      OBSERVER_IDLE_INTERVAL_MS,
+      Math.max(1e3, result.nextRetryAtMs - nowMs)
+    );
+  }
+  return OBSERVER_IDLE_INTERVAL_MS;
+}
+function phaseForResult(result) {
+  if (result.kind === "unauthenticated") return "waiting_for_auth";
+  if (result.kind !== "completed") return "idle";
+  return result.outcome === "failed" || result.outcome === "exhausted" || result.outcome === "backing_off" || result.outcome === "throttled" || result.outcome === "busy" ? "backing_off" : "idle";
+}
+function outcomeForResult(result) {
+  return result.kind === "completed" ? result.outcome : result.kind;
+}
+function createObserverSyncLoop(opts) {
+  const nowMs = opts.nowMs ?? Date.now;
+  const runOnce = opts.runOnce ?? runObserverSyncCycleSubprocess;
+  let stopping = false;
+  let wakePending = false;
+  let wakeWaiter = null;
+  let activeAbort = null;
+  const wake = () => {
+    wakePending = true;
+    activeAbort?.abort();
+    wakeWaiter?.();
+  };
+  const wait = async (delayMs) => {
+    if (stopping || wakePending) {
+      wakePending = false;
+      return "woken";
+    }
+    return await new Promise((resolve) => {
+      const timer = setTimeout(
+        () => {
+          wakeWaiter = null;
+          resolve("elapsed");
+        },
+        Math.min(delayMs, OBSERVER_MAX_TIMER_DELAY_MS)
+      );
+      wakeWaiter = () => {
+        clearTimeout(timer);
+        wakeWaiter = null;
+        wakePending = false;
+        resolve("woken");
+      };
+    });
+  };
+  const waitUntil = async (deadlineMs) => {
+    while (!stopping) {
+      const remainingMs = deadlineMs - nowMs();
+      if (remainingMs <= 0) return;
+      if (await wait(remainingMs) === "woken") return;
+    }
+  };
+  const done = (async () => {
+    while (!stopping) {
+      const attemptedAtMs = nowMs();
+      opts.onUpdate({
+        phase: "syncing",
+        heartbeatAtMs: attemptedAtMs,
+        lastAttemptAtMs: attemptedAtMs,
+        nextAttemptAtMs: void 0,
+        lastError: void 0
+      });
+      activeAbort = new AbortController();
+      let result;
+      try {
+        result = await runOnce({ signal: activeAbort.signal });
+      } catch (error) {
+        activeAbort = null;
+        if (stopping) break;
+        if (wakePending) {
+          wakePending = false;
+          if (error instanceof ObserverSyncCycleAbortedError) {
+            continue;
+          }
+          opts.onUpdate({
+            phase: "backing_off",
+            heartbeatAtMs: nowMs(),
+            lastOutcome: "error",
+            lastError: truncateError(error),
+            nextAttemptAtMs: nowMs()
+          });
+          continue;
+        }
+        const nextAttemptAtMs = nowMs() + OBSERVER_IDLE_INTERVAL_MS;
+        opts.onUpdate({
+          phase: "backing_off",
+          heartbeatAtMs: nowMs(),
+          lastOutcome: "error",
+          lastError: truncateError(error),
+          nextAttemptAtMs
+        });
+        await waitUntil(nextAttemptAtMs);
+        continue;
+      }
+      activeAbort = null;
+      if (stopping) break;
+      const completedAtMs = nowMs();
+      opts.onCycle?.(result, {
+        startedAtMs: attemptedAtMs,
+        completedAtMs
+      });
+      const delayMs = delayForResult(result, completedAtMs);
+      const successful = result.kind === "completed" && (result.outcome === "drained" || result.outcome === "pending");
+      opts.onUpdate({
+        phase: phaseForResult(result),
+        ...result.kind !== "disabled" ? { environment: result.environment } : {},
+        heartbeatAtMs: completedAtMs,
+        ...successful ? { lastSuccessAtMs: completedAtMs } : {},
+        lastOutcome: outcomeForResult(result),
+        lastError: result.kind === "unauthenticated" ? "FML login required" : result.kind === "completed" && (result.outcome === "failed" || result.outcome === "exhausted") ? `${result.failed} failed, ${result.exhausted} exhausted` : void 0,
+        nextAttemptAtMs: completedAtMs + delayMs
+      });
+      if (result.kind === "completed" && (result.uploadedBytes > 0 || result.outcome !== "drained")) {
+        console.log(
+          `${new Date(completedAtMs).toISOString()} sync ${result.outcome}: ${result.uploadedBytes} bytes, ${result.failed} failed`
+        );
+      }
+      await waitUntil(completedAtMs + delayMs);
+    }
+  })();
+  return {
+    done,
+    wake,
+    stop: () => {
+      if (stopping) return;
+      stopping = true;
+      activeAbort?.abort();
+      wake();
+    }
+  };
+}
+
+// src/observer-server.ts
+var HEARTBEAT_INTERVAL_MS = 5e3;
+var STATE_UPDATE_RETRY_MS = 50;
+var STARTUP_STATE_UPDATE_TIMEOUT_MS = 5e3;
+var PORT_FALLBACK_COUNT = 10;
+var HOOK_REJECTION_WARNING_INTERVAL_MS = 6e4;
+var HOOK_INBOX_DRAIN_INTERVAL_MS = 1e3;
+var HOOK_QUARANTINE_PRUNE_INTERVAL_MS = 5 * 60 * 1e3;
+var OBSERVER_DIRECTORY_LEASE = {
+  stateFile: FML_OBSERVER_STATE_FILE,
+  lockFile: FML_OBSERVER_LOCK_FILE
+};
+var DATABASE_LEASE = {
+  stateFile: FML_PANOPTICON_DB_OBSERVER_STATE_FILE,
+  lockFile: FML_PANOPTICON_DB_OBSERVER_LOCK_FILE
+};
+function removeInitialLeaseBestEffort(instanceId, lease) {
+  try {
+    removeObserverStateIfOwned(instanceId, lease);
+  } catch {
+  }
+}
+function removeInitialLeasesBestEffort(instanceId) {
+  removeInitialLeaseBestEffort(instanceId, DATABASE_LEASE);
+  removeInitialLeaseBestEffort(instanceId, OBSERVER_DIRECTORY_LEASE);
+}
+function persistedPort() {
+  try {
+    const parsed = JSON.parse(
+      fs.readFileSync(FML_OBSERVER_ENDPOINT_FILE, "utf8")
+    );
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return null;
+    }
+    const port = parsed.port;
+    return typeof port === "number" && Number.isInteger(port) && port > 0 && port <= 65535 ? port : null;
+  } catch {
+    return null;
+  }
+}
+function writeEndpoint(port) {
+  const tempFile = `${FML_OBSERVER_ENDPOINT_FILE}.${process.pid}.tmp`;
+  fs.writeFileSync(
+    tempFile,
+    `${JSON.stringify({
+      service: OBSERVER_SERVICE_NAME,
+      protocolVersion: OBSERVER_PROTOCOL_VERSION,
+      host: FML_OBSERVER_HOST,
+      port
+    })}
+`,
+    { mode: 384 }
+  );
+  fs.renameSync(tempFile, FML_OBSERVER_ENDPOINT_FILE);
+}
+async function tryListen(server2, port) {
+  return await new Promise((resolve, reject) => {
+    const onError = (error) => {
+      server2.off("listening", onListening);
+      if (error.code === "EADDRINUSE") resolve(false);
+      else reject(error);
+    };
+    const onListening = () => {
+      server2.off("error", onError);
+      resolve(true);
+    };
+    server2.once("error", onError);
+    server2.once("listening", onListening);
+    server2.listen(port, FML_OBSERVER_HOST);
+  });
+}
+async function listenObserver(server2) {
+  const explicitPort = process.env.FML_OBSERVER_PORT !== void 0 || process.env.PANOPTICON_PORT !== void 0;
+  const preferredPort = explicitPort ? FML_OBSERVER_PORT : persistedPort() ?? FML_OBSERVER_PORT;
+  const attempts = explicitPort ? 1 : PORT_FALLBACK_COUNT;
+  for (let offset = 0; offset < attempts; offset += 1) {
+    const port = preferredPort + offset;
+    if (port > 65535) break;
+    if (await tryListen(server2, port)) return port;
+  }
+  throw new Error(
+    explicitPort ? `FML observer port ${preferredPort} is already in use` : `No available FML observer port in ${preferredPort}-${Math.min(65535, preferredPort + attempts - 1)}`
+  );
+}
+function cycleOutcome(result) {
+  if (result.kind === "completed") {
+    return {
+      environment: result.environment,
+      outcome: result.outcome,
+      uploadedBytes: result.uploadedBytes,
+      failed: result.failed,
+      ...result.failed > 0 ? { error: `${result.failed} upload attempt(s) failed` } : {}
+    };
+  }
+  return {
+    ...result.kind === "unauthenticated" ? { environment: result.environment } : {},
+    outcome: result.kind,
+    uploadedBytes: 0,
+    failed: 0,
+    ...result.kind === "unauthenticated" ? { error: "FML login required" } : {}
+  };
+}
+var hookSpoolMaxBytes = parseHookSpoolMaxBytes(
+  process.env.FML_HOOK_SPOOL_MAX_BYTES
+);
+var hookQuarantineMaxAgeMs = parseHookQuarantineMaxAgeMs(
+  process.env.FML_HOOK_QUARANTINE_MAX_AGE_DAYS
+);
+var otlpSpoolMaxBytes = parseOtlpSpoolMaxBytes(
+  process.env.FML_OTLP_SPOOL_MAX_BYTES
+);
+ensureDirs();
+var isolationWarning = observerOnlyOverrideWarning();
+if (isolationWarning) console.warn(isolationWarning);
+var initial = createInitialObserverState();
+if (!claimObserverState(initial, OBSERVER_DIRECTORY_LEASE)) {
+  console.error("FML observer is already running");
+  process.exit(1);
+}
+var databaseLeaseClaimed = false;
+try {
+  databaseLeaseClaimed = claimObserverState(initial, {
+    ...DATABASE_LEASE,
+    liveOwnerPolicy: "process_identity"
+  });
+} catch (error) {
+  removeInitialLeasesBestEffort(initial.instanceId);
+  console.error(
+    `FML observer could not claim database lease for ${FML_PANOPTICON_DB_FILE}: ${error instanceof Error ? error.message : String(error)}`
+  );
+  process.exit(1);
+}
+if (!databaseLeaseClaimed) {
+  removeInitialLeaseBestEffort(initial.instanceId, OBSERVER_DIRECTORY_LEASE);
+  console.error(
+    `FML database ${FML_PANOPTICON_DB_FILE} is already in use by another observer. Stop that observer using the same FML_STATE_DIR, or select a different absolute FML_STATE_DIR.`
+  );
+  process.exit(1);
+}
+var state = initial;
+var shuttingDown = false;
+var fatalShutdownScheduled = false;
+var heartbeatTimer = null;
+var hookInboxDrainTimer = null;
+var hookInboxDrainPromise = null;
+var hookQuarantinePruneTimer = null;
+var stateUpdateRetryTimer = null;
+var syncLoop = null;
+var hookSyncLoop = null;
+var otlpSyncLoop = null;
+var pendingStateUpdate = null;
+var authToken;
+var database;
+try {
+  authToken = getOrCreateObserverAuthToken(FML_OBSERVER_AUTH_TOKEN_FILE);
+  database = openObserverDatabase(FML_PANOPTICON_DB_FILE, {
+    // FML_STATE_DIR can be caller-managed. Keep SQLite payload files private
+    // without changing permissions on the shared parent directory.
+    restrictDatabaseDirectory: false,
+    ...hookSpoolMaxBytes === void 0 ? {} : { maxHookSpoolBytes: hookSpoolMaxBytes },
+    ...hookQuarantineMaxAgeMs === void 0 ? {} : { maxHookQuarantineAgeMs: hookQuarantineMaxAgeMs },
+    ...otlpSpoolMaxBytes === void 0 ? {} : { maxOtlpSpoolBytes: otlpSpoolMaxBytes }
+  });
+} catch (error) {
+  removeInitialLeasesBestEffort(initial.instanceId);
+  console.error(
+    `FML observer could not open database ${FML_PANOPTICON_DB_FILE}: ${error instanceof Error ? error.message : String(error)}`
+  );
+  process.exit(1);
+}
+var rejectedHookCaptures = 0;
+var lastRejectedAtMs;
+var lastRejectedReason;
+var lastRejectedTarget;
+var hookRejectionWarnings = /* @__PURE__ */ new Map();
+var unsupportedInboxSchemaReported = false;
+var recordHookRejection = (reason, target) => {
+  const now = Date.now();
+  rejectedHookCaptures += 1;
+  lastRejectedAtMs = now;
+  lastRejectedReason = reason;
+  lastRejectedTarget = target;
+  const lastWarningAtMs = hookRejectionWarnings.get(reason) ?? 0;
+  if (now - lastWarningAtMs < HOOK_REJECTION_WARNING_INTERVAL_MS) return;
+  hookRejectionWarnings.set(reason, now);
+  console.warn(
+    `[fml] Rejected hook capture: reason=${reason}${target ? ` target=${target}` : ""}`
+  );
+};
+var hookRejectionStatus = () => ({
+  rejected: rejectedHookCaptures,
+  ...lastRejectedAtMs !== void 0 ? { lastRejectedAtMs } : {},
+  ...lastRejectedReason !== void 0 ? { lastRejectedReason } : {},
+  ...lastRejectedTarget !== void 0 ? { lastRejectedTarget } : {}
+});
+var packageVersion = true ? "0.8.0-rc.2+bed6eaed" : "dev";
+var health = () => ({
+  status: "ok",
+  service: OBSERVER_SERVICE_NAME,
+  protocolVersion: OBSERVER_PROTOCOL_VERSION,
+  instanceId: state.instanceId,
+  pid: state.pid,
+  port: state.port,
+  version: packageVersion,
+  capabilities: ["hook-capture-v1", "otlp-http-capture-v1", "panopticon-db-v1"]
+});
+var publicStatus = async () => ({
+  ...health(),
+  observer: state,
+  sync: createCliRawSync({ continuous: true }).status(),
+  hooks: {
+    ...hookSyncLoop?.status() ?? {
+      phase: "idle",
+      pending: database.countPendingHookEvents()
+    },
+    quarantined: database.countQuarantinedHookEvents(),
+    spool: database.getHookSpoolStatus(),
+    inbox: await readHookInboxStatusAsync(),
+    ...hookRejectionStatus()
+  },
+  otlp: {
+    ...otlpSyncLoop?.status() ?? {
+      phase: "idle",
+      pending: database.countPendingOtlpEnvelopes()
+    },
+    spool: database.getOtlpSpoolStatus()
+  }
+});
+function bothObserverLeasesAreOwned(instanceId) {
+  return observerLeaseIsOwned(instanceId, OBSERVER_DIRECTORY_LEASE.lockFile) && observerLeaseIsOwned(instanceId, DATABASE_LEASE.lockFile);
+}
+function updateBothObserverStates(current, update) {
+  updateObserverState(
+    current,
+    update,
+    OBSERVER_DIRECTORY_LEASE.stateFile,
+    OBSERVER_DIRECTORY_LEASE.lockFile
+  );
+  const databaseState = updateObserverState(
+    current,
+    update,
+    DATABASE_LEASE.stateFile,
+    DATABASE_LEASE.lockFile
+  );
+  return databaseState;
+}
+function removeBothObserverStates(instanceId) {
+  try {
+    removeObserverStateIfOwned(instanceId, DATABASE_LEASE);
+  } finally {
+    removeObserverStateIfOwned(instanceId, OBSERVER_DIRECTORY_LEASE);
+  }
+}
+var server;
+var shutdown = async () => {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  if (heartbeatTimer) clearInterval(heartbeatTimer);
+  if (hookInboxDrainTimer) clearInterval(hookInboxDrainTimer);
+  if (hookQuarantinePruneTimer) clearInterval(hookQuarantinePruneTimer);
+  if (stateUpdateRetryTimer) clearTimeout(stateUpdateRetryTimer);
+  if (bothObserverLeasesAreOwned(state.instanceId)) {
+    try {
+      state = updateBothObserverStates(state, {
+        phase: "stopping",
+        heartbeatAtMs: Date.now(),
+        nextAttemptAtMs: void 0
+      });
+    } catch {
+    }
+  }
+  syncLoop?.stop();
+  hookSyncLoop?.stop();
+  otlpSyncLoop?.stop();
+  await new Promise((resolve) => server.close(() => resolve()));
+  await syncLoop?.done.catch(() => {
+  });
+  await hookSyncLoop?.done.catch(() => {
+  });
+  await otlpSyncLoop?.done.catch(() => {
+  });
+  await hookInboxDrainPromise?.catch(() => {
+  });
+  try {
+    database.close();
+  } finally {
+    removeBothObserverStates(state.instanceId);
+  }
+};
+var scheduleFatalShutdown = (error) => {
+  console.error(error);
+  if (fatalShutdownScheduled) return;
+  fatalShutdownScheduled = true;
+  setImmediate(() => {
+    void shutdown().finally(() => process.exit(1));
+  });
+};
+var flushStateUpdate = () => {
+  stateUpdateRetryTimer = null;
+  if (!pendingStateUpdate || shuttingDown || fatalShutdownScheduled) {
+    return false;
+  }
+  const update = pendingStateUpdate;
+  try {
+    state = updateBothObserverStates(state, update);
+    pendingStateUpdate = null;
+    database.setRuntimeState("observer", state);
+    return true;
+  } catch (error) {
+    if (error instanceof ObserverStateMutationBusyError) {
+      stateUpdateRetryTimer = setTimeout(
+        flushStateUpdate,
+        STATE_UPDATE_RETRY_MS
+      );
+      stateUpdateRetryTimer.unref();
+      return false;
+    }
+    scheduleFatalShutdown(error);
+    return false;
+  }
+};
+var updateState = (update) => {
+  pendingStateUpdate = { ...pendingStateUpdate, ...update };
+  if (stateUpdateRetryTimer) return false;
+  return flushStateUpdate();
+};
+var updateStartupState = async (update) => {
+  const deadlineMs = Date.now() + STARTUP_STATE_UPDATE_TIMEOUT_MS;
+  while (true) {
+    try {
+      state = updateBothObserverStates(state, update);
+      return;
+    } catch (error) {
+      if (!(error instanceof ObserverStateMutationBusyError) || Date.now() >= deadlineMs) {
+        throw error;
+      }
+      await new Promise(
+        (resolve) => setTimeout(resolve, STATE_UPDATE_RETRY_MS)
+      );
+    }
+  }
+};
+var terminalHookCaptureError = (error) => {
+  if (error instanceof ObserverHookSpoolEntryTooLargeError) return true;
+  if (!(error instanceof Error)) return false;
+  return /^(?:Hook event|Hook destination) .+ (?:exceeds|must (?:not )?be)/u.test(
+    error.message
+  );
+};
+var captureHookRequest = (request, metadata) => {
+  const event = normalizeObserverHookCapture(
+    request,
+    metadata ? {
+      nowMs: () => metadata.capturedAtMs,
+      syncId: () => metadata.syncId,
+      ...metadata.repository ? { repository: metadata.repository } : {}
+    } : {}
+  );
+  if (!event) {
+    recordHookRejection("unnormalizable_event", request.target);
+    return "terminal_rejected";
+  }
+  let destination = null;
+  if (metadata) {
+    destination = metadata.destination ?? null;
+  } else {
+    try {
+      destination = getActiveHookDestinationBinding();
+    } catch {
+    }
+  }
+  try {
+    database.captureHookEvent({
+      ...event,
+      ...destination ? { destination } : {}
+    });
+  } catch (error) {
+    const terminal = terminalHookCaptureError(error);
+    recordHookRejection(
+      error instanceof ObserverHookSpoolEntryTooLargeError ? "spool_entry_too_large" : "capture_failed",
+      request.target
+    );
+    return terminal ? "terminal_rejected" : "retry";
+  }
+  hookSyncLoop?.wake();
+  return "committed";
+};
+var captureHookInboxEntry = (entry) => captureHookRequest(entry.request, entry);
+var drainPendingHookInbox = () => {
+  if (hookInboxDrainPromise) return hookInboxDrainPromise;
+  const drainPromise = (async () => {
+    const result = await drainHookInbox(captureHookInboxEntry);
+    if (result.malformed > 0) recordHookRejection("inbox_malformed");
+    if (result.failed > 0) recordHookRejection("inbox_drain_failed");
+    if (result.unsupported > 0 && !unsupportedInboxSchemaReported) {
+      recordHookRejection("inbox_unsupported_schema");
+      unsupportedInboxSchemaReported = true;
+    } else if (result.unsupported === 0) {
+      unsupportedInboxSchemaReported = false;
+    }
+  })();
+  hookInboxDrainPromise = drainPromise;
+  void drainPromise.then(
+    () => {
+      if (hookInboxDrainPromise === drainPromise) hookInboxDrainPromise = null;
+    },
+    () => {
+      if (hookInboxDrainPromise === drainPromise) hookInboxDrainPromise = null;
+    }
+  );
+  return drainPromise;
+};
+server = createObserverHttpServer({
+  authToken,
+  getHealth: health,
+  getStatus: publicStatus,
+  onHook: (payload) => {
+    const request = parseHookCaptureRequest(payload);
+    if (!request) {
+      recordHookRejection("invalid_envelope");
+      return;
+    }
+    const metadata = parseHookInboxMetadata(payload) ?? void 0;
+    const outcome = captureHookRequest(request, metadata);
+    if (metadata && outcome === "committed") {
+      acknowledgeHookInboxEntry(metadata);
+    } else if (metadata && outcome === "terminal_rejected") {
+      retireHookInboxEntry(metadata, "terminal_rejected");
+    }
+  },
+  onOtlp: (envelope) => {
+    let destination = null;
+    try {
+      destination = getActiveOtlpDestinationBinding();
+    } catch {
+    }
+    database.captureOtlpEnvelope({
+      ...envelope,
+      ...destination ? { destination } : {}
+    });
+    otlpSyncLoop?.wake();
+  },
+  onWake: () => {
+    syncLoop?.wake();
+    hookSyncLoop?.wake(true);
+    otlpSyncLoop?.wake();
+  },
+  onShutdown: () => {
+    void shutdown().finally(() => process.exit(0));
+  }
+});
+try {
+  const port = await listenObserver(server);
+  await updateStartupState({
+    port,
+    phase: "idle",
+    heartbeatAtMs: Date.now()
+  });
+  writeEndpoint(port);
+  database.setRuntimeState("observer", state);
+  console.log(
+    `${(/* @__PURE__ */ new Date()).toISOString()} FML observer listening on ${FML_OBSERVER_HOST}:${port}`
+  );
+  heartbeatTimer = setInterval(() => {
+    updateState({ heartbeatAtMs: Date.now() });
+  }, HEARTBEAT_INTERVAL_MS);
+  heartbeatTimer.unref();
+  await drainPendingHookInbox();
+  hookInboxDrainTimer = setInterval(() => {
+    void drainPendingHookInbox();
+  }, HOOK_INBOX_DRAIN_INTERVAL_MS);
+  hookInboxDrainTimer.unref();
+  hookQuarantinePruneTimer = setInterval(() => {
+    try {
+      database.countQuarantinedHookEvents();
+    } catch (error) {
+      scheduleFatalShutdown(error);
+    }
+  }, HOOK_QUARANTINE_PRUNE_INTERVAL_MS);
+  hookQuarantinePruneTimer.unref();
+  hookSyncLoop = createHookSyncLoop({
+    database,
+    version: packageVersion
+  });
+  void hookSyncLoop.done.catch((error) => {
+    if (!shuttingDown) scheduleFatalShutdown(error);
+  });
+  otlpSyncLoop = createOtlpSyncLoop({
+    database,
+    version: packageVersion
+  });
+  void otlpSyncLoop.done.catch((error) => {
+    if (!shuttingDown) scheduleFatalShutdown(error);
+  });
+  syncLoop = createObserverSyncLoop({
+    onUpdate: (update) => {
+      updateState(update);
+    },
+    onCycle: (result, timing) => {
+      try {
+        database.recordSyncRun({ ...timing, ...cycleOutcome(result) });
+      } catch (error) {
+        scheduleFatalShutdown(error);
+      }
+    }
+  });
+  void syncLoop.done.catch((error) => {
+    if (!shuttingDown) scheduleFatalShutdown(error);
+  });
+} catch (error) {
+  console.error(error);
+  await shutdown().catch(() => {
+  });
+  process.exit(1);
+}
+for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+  process.once(signal, () => {
+    void shutdown().finally(() => process.exit(0));
+  });
+}