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

package/dist/chunk-F66IBM3Z.js

@@ -0,0 +1,1037 @@
+import {
+  resolveRepoFromCwdAsync
+} from "./chunk-T5YVLSUC.js";
+import {
+  getActiveEnv,
+  getSiteUrlForConvexUrl,
+  getSyncDestinationIdentity,
+  getValidToken
+} from "./chunk-7DR5X7XI.js";
+
+// src/hooks/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 HOOK_UPLOAD_TIMEOUT_MS = 3e4;
+var MAX_HOOK_EVENT_ROW_JSON_BYTES = 2 * 1024 * 1024;
+var MAX_SESSION_ROW_JSON_BYTES = 2 * 1024 * 1024;
+var MAX_BATCH_JSON_BYTES = 3 * 1024 * 1024;
+var MAX_SESSION_RELATIONSHIPS_PER_ROW = 100;
+var MAX_EXTRACTED_TEXT_BYTES = 64 * 1024;
+var MAX_CONTEXT_TEXT_BYTES = 16 * 1024;
+var MAX_REJECTION_REASON_BYTES = 3 * 1024;
+function retryAtMs(response, now) {
+  const value = response.headers.get("Retry-After");
+  if (!value) return void 0;
+  const seconds = Number(value);
+  const candidate = Number.isFinite(seconds) ? now + Math.max(0, seconds) * 1e3 : Date.parse(value);
+  if (!Number.isFinite(candidate)) return void 0;
+  return Math.min(now + MAX_RETRY_AFTER_MS, Math.max(now, candidate));
+}
+function errorText(status, body) {
+  if (body && typeof body === "object" && !Array.isArray(body)) {
+    const error = body.error;
+    if (typeof error === "string" && error.length > 0) {
+      return error.length > 1e3 ? `${error.slice(0, 997)}...` : error;
+    }
+  }
+  return `Sync request failed with HTTP ${status}`;
+}
+function utf8Bytes(value) {
+  return Buffer.byteLength(value, "utf8");
+}
+function sha256(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function utf8Prefix(value, maxBytes) {
+  let low = 0;
+  let high = value.length;
+  while (low < high) {
+    const middle = Math.ceil((low + high) / 2);
+    if (utf8Bytes(value.slice(0, middle)) <= 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 codeUnitPrefix(value, requestedEnd) {
+  let end = Math.min(value.length, Math.max(0, requestedEnd));
+  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 boundedText(value, maxBytes, field) {
+  const originalBytes = utf8Bytes(value);
+  if (originalBytes <= maxBytes) return value;
+  const marker = `
+[fml:${field}:truncated originalBytes=${originalBytes} sha256=${sha256(value)}]`;
+  const markerBytes = utf8Bytes(marker);
+  if (markerBytes >= maxBytes) {
+    throw new Error(`${field} cannot fit its truncation marker`);
+  }
+  return `${utf8Prefix(value, maxBytes - markerBytes)}${marker}`;
+}
+function requireUploadString(value, field, maxBytes) {
+  if (value.length === 0) throw new Error(`${field} must not be empty`);
+  if (utf8Bytes(value) > maxBytes) {
+    throw new Error(`${field} exceeds ${maxBytes} UTF-8 bytes`);
+  }
+}
+function optionalBoundedText(value, maxBytes, field) {
+  return value === void 0 ? void 0 : boundedText(value, maxBytes, field);
+}
+function serializedJson(value, description) {
+  let result;
+  try {
+    result = JSON.stringify(value);
+  } catch (error) {
+    throw new Error(`${description} is not JSON-serializable`, {
+      cause: error
+    });
+  }
+  if (result === void 0) {
+    throw new Error(`${description} is not JSON-serializable`);
+  }
+  return result;
+}
+function rejectionReason(prefix, error) {
+  const detail = error instanceof Error ? error.message : String(error);
+  return boundedText(
+    `${prefix}: ${detail}`,
+    MAX_REJECTION_REASON_BYTES,
+    "rejection_reason"
+  );
+}
+function terminalHttpStatus(status) {
+  return status === 400 || status === 413 || status === 422;
+}
+function perGroupServerFailure(status) {
+  return status >= 500 && status <= 599;
+}
+function abortReason(signal) {
+  return signal.reason ?? new Error("Hook sync aborted");
+}
+async function abortable(operation, signal) {
+  if (!signal) return await operation;
+  if (signal.aborted) {
+    void operation.catch(() => {
+    });
+    throw abortReason(signal);
+  }
+  return await new Promise((resolve, reject) => {
+    const onAbort = () => reject(abortReason(signal));
+    signal.addEventListener("abort", onAbort, { once: true });
+    void operation.then(
+      (value) => {
+        signal.removeEventListener("abort", onAbort);
+        resolve(value);
+      },
+      (error) => {
+        signal.removeEventListener("abort", onAbort);
+        reject(error);
+      }
+    );
+    if (signal.aborted) onAbort();
+  });
+}
+function sessionAcceptance(body, sessionId) {
+  if (!body || typeof body !== "object" || Array.isArray(body)) {
+    return {
+      ok: false,
+      error: "Invalid v2 session response: expected a JSON object"
+    };
+  }
+  const accepted = body.accepted;
+  if (!Array.isArray(accepted)) {
+    return {
+      ok: false,
+      error: "Invalid v2 session response: expected an accepted session ID array"
+    };
+  }
+  if (accepted.some(
+    (value) => typeof value !== "string" || value !== sessionId
+  ) || accepted.length > 1) {
+    return {
+      ok: false,
+      error: "Invalid v2 session response: accepted contains an unrequested or duplicate session ID"
+    };
+  }
+  return { ok: true, accepted: accepted.length === 1 };
+}
+function hookAcceptance(body, records) {
+  if (!body || typeof body !== "object" || Array.isArray(body)) {
+    return {
+      ok: false,
+      error: "Invalid v2 hook response: expected a JSON object"
+    };
+  }
+  const accepted = body.accepted;
+  if (!Array.isArray(accepted)) {
+    return {
+      ok: false,
+      error: "Invalid v2 hook response: expected an accepted sync ID array"
+    };
+  }
+  const requestedSyncIds = new Set(records.map((record) => record.syncId));
+  const acceptedSyncIds = /* @__PURE__ */ new Set();
+  for (const value of accepted) {
+    if (typeof value !== "string" || !requestedSyncIds.has(value)) {
+      return {
+        ok: false,
+        error: "Invalid v2 hook response: accepted contains an unrequested sync ID"
+      };
+    }
+    if (acceptedSyncIds.has(value)) {
+      return {
+        ok: false,
+        error: "Invalid v2 hook response: accepted contains a duplicate sync ID"
+      };
+    }
+    acceptedSyncIds.add(value);
+  }
+  return {
+    ok: true,
+    acceptedSyncIds: [...acceptedSyncIds],
+    omittedSyncIds: records.map((record) => record.syncId).filter((syncId) => !acceptedSyncIds.has(syncId))
+  };
+}
+function omittedHookReceiptError(omittedCount) {
+  return `Server did not accept ${omittedCount} hook event${omittedCount === 1 ? "" : "s"}; retrying after authorization refresh`;
+}
+function retryDelayForRecords(records) {
+  const retryCount = records.reduce(
+    (highest, record) => Math.max(highest, record.retryCount),
+    0
+  );
+  return Math.min(
+    MAX_RETRY_INTERVAL_MS,
+    MIN_RETRY_INTERVAL_MS * 2 ** Math.min(retryCount, 8)
+  );
+}
+async function postSyncRows(destination, table, rows, opts) {
+  const headers = {
+    Authorization: destination.authorization,
+    "Content-Type": "application/json",
+    "User-Agent": `fml/${opts.version}`,
+    "X-Panopticon-Version": opts.version
+  };
+  const request = opts.fetch ?? fetch;
+  const timeoutSignal = AbortSignal.timeout(HOOK_UPLOAD_TIMEOUT_MS);
+  const signal = opts.signal ? AbortSignal.any([opts.signal, timeoutSignal]) : timeoutSignal;
+  let response;
+  try {
+    response = await request(`${destination.targetUrl}/v2/sync`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ producer: "hook", table, rows }),
+      signal
+    });
+  } catch (error) {
+    if (opts.signal?.aborted) throw opts.signal.reason ?? error;
+    const detail = error instanceof Error ? error.message : String(error);
+    return {
+      ok: false,
+      status: 0,
+      body: null,
+      error: detail.length > 1e3 ? `Hook sync request failed: ${detail.slice(0, 970)}...` : `Hook sync request failed: ${detail}`
+    };
+  }
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+    body = null;
+  }
+  return {
+    ok: response.ok,
+    status: response.status,
+    body,
+    ...response.ok ? {} : { error: errorText(response.status, body) },
+    ...response.status === 429 || response.status === 503 ? { retryAtMs: retryAtMs(response, opts.nowMs()) } : {}
+  };
+}
+function boundedPayloadRow(baseRow, payload) {
+  const initialJson = serializedJson(baseRow, "Hook event row");
+  const initialBytes = utf8Bytes(initialJson);
+  if (initialBytes <= MAX_HOOK_EVENT_ROW_JSON_BYTES) {
+    return { row: baseRow, jsonBytes: initialBytes };
+  }
+  const payloadJson = serializedJson(payload, "Hook event payload");
+  const metadata = {
+    truncated: true,
+    format: "json-prefix-v1",
+    originalBytes: utf8Bytes(payloadJson),
+    sha256: sha256(payloadJson)
+  };
+  let low = 0;
+  let high = payloadJson.length;
+  let bestRow = null;
+  let bestBytes = 0;
+  while (low <= high) {
+    const middle = Math.floor((low + high) / 2);
+    const candidate = {
+      ...baseRow,
+      payload: {
+        _fmlTruncated: metadata,
+        preview: codeUnitPrefix(payloadJson, middle)
+      }
+    };
+    const candidateBytes = utf8Bytes(
+      serializedJson(candidate, "Truncated hook event row")
+    );
+    if (candidateBytes <= MAX_HOOK_EVENT_ROW_JSON_BYTES) {
+      bestRow = candidate;
+      bestBytes = candidateBytes;
+      low = middle + 1;
+    } else {
+      high = middle - 1;
+    }
+  }
+  if (!bestRow) {
+    throw new Error(
+      `Hook event row cannot fit within ${MAX_HOOK_EVENT_ROW_JSON_BYTES} UTF-8 bytes`
+    );
+  }
+  return { row: bestRow, jsonBytes: bestBytes };
+}
+async function prepareHookEvent(record, signal) {
+  requireUploadString(record.syncId, "Hook event sync ID", 1024);
+  requireUploadString(record.sessionId, "Hook event session ID", 4096);
+  requireUploadString(record.eventType, "Hook event type", 1024);
+  requireUploadString(record.target, "Hook event target", 256);
+  if (!Number.isSafeInteger(record.timestampMs) || record.timestampMs < 0) {
+    throw new Error("Hook event timestamp must be a non-negative safe integer");
+  }
+  const repositoryInfo = await repositoryForRecord(record, signal);
+  const repository = repositoryInfo?.repo;
+  const cwd = optionalBoundedText(record.cwd, MAX_CONTEXT_TEXT_BYTES, "cwd");
+  const boundedRepository = optionalBoundedText(
+    repository,
+    MAX_CONTEXT_TEXT_BYTES,
+    "repository"
+  );
+  const toolName = optionalBoundedText(
+    record.toolName,
+    MAX_CONTEXT_TEXT_BYTES,
+    "tool_name"
+  );
+  const userPrompt = optionalBoundedText(
+    record.userPrompt,
+    MAX_EXTRACTED_TEXT_BYTES,
+    "user_prompt"
+  );
+  const filePath = optionalBoundedText(
+    record.filePath,
+    MAX_CONTEXT_TEXT_BYTES,
+    "file_path"
+  );
+  const command = optionalBoundedText(
+    record.command,
+    MAX_EXTRACTED_TEXT_BYTES,
+    "command"
+  );
+  const plan = optionalBoundedText(
+    record.plan,
+    MAX_EXTRACTED_TEXT_BYTES,
+    "plan"
+  );
+  const allowedPrompts = optionalBoundedText(
+    record.allowedPrompts,
+    MAX_EXTRACTED_TEXT_BYTES,
+    "allowed_prompts"
+  );
+  const toolResult = optionalBoundedText(
+    record.toolResult,
+    MAX_EXTRACTED_TEXT_BYTES,
+    "tool_result"
+  );
+  const baseRow = {
+    sessionId: record.sessionId,
+    syncId: record.syncId,
+    eventType: record.eventType,
+    timestampMs: record.timestampMs,
+    target: record.target,
+    payload: record.payload,
+    ...cwd ? { cwd } : {},
+    ...boundedRepository ? { repository: boundedRepository } : {},
+    ...toolName ? { toolName } : {},
+    ...userPrompt ? { userPrompt } : {},
+    ...filePath ? { filePath } : {},
+    ...command ? { command } : {},
+    ...plan ? { plan } : {},
+    ...allowedPrompts ? { allowedPrompts } : {},
+    ...toolResult ? { toolResult } : {}
+  };
+  const bounded = boundedPayloadRow(baseRow, record.payload);
+  return { record, repositoryInfo, ...bounded };
+}
+async function repositoryForRecord(record, signal) {
+  if (record.repository) return { repo: record.repository, branch: null };
+  return record.cwd ? await abortable(resolveRepoFromCwdAsync(record.cwd, signal), signal) : null;
+}
+function hookSessionRow(events) {
+  const records = events.map((event) => event.record);
+  const first = records[0];
+  if (!first)
+    throw new Error("cannot build a session from an empty hook batch");
+  const startedAtMs = Math.min(...records.map((record) => record.timestampMs));
+  const firstPromptValue = records.find(
+    (record) => record.userPrompt
+  )?.userPrompt;
+  const firstPrompt = optionalBoundedText(
+    firstPromptValue,
+    MAX_EXTRACTED_TEXT_BYTES,
+    "session_first_prompt"
+  );
+  const repositoriesByName = /* @__PURE__ */ new Map();
+  const cwdsByPath = /* @__PURE__ */ new Map();
+  for (const [order, event] of events.entries()) {
+    const { record, repositoryInfo } = event;
+    if (repositoryInfo) {
+      const repository = boundedText(
+        repositoryInfo.repo,
+        MAX_CONTEXT_TEXT_BYTES,
+        "session_repository"
+      );
+      const branch = repositoryInfo.branch ? boundedText(
+        repositoryInfo.branch,
+        MAX_CONTEXT_TEXT_BYTES,
+        "session_branch"
+      ) : void 0;
+      const existing = repositoriesByName.get(repository);
+      if (!existing) {
+        repositoriesByName.set(repository, {
+          repository,
+          firstSeenMs: record.timestampMs,
+          ...branch ? { branch } : {},
+          order
+        });
+      } else {
+        if (record.timestampMs < existing.firstSeenMs) {
+          existing.firstSeenMs = record.timestampMs;
+          existing.branch = branch;
+        } else if (existing.branch === void 0 && branch !== void 0) {
+          existing.branch = branch;
+        }
+      }
+    }
+    const cwd = optionalBoundedText(
+      record.cwd,
+      MAX_CONTEXT_TEXT_BYTES,
+      "session_cwd"
+    );
+    if (cwd) {
+      const existing = cwdsByPath.get(cwd);
+      if (!existing) {
+        cwdsByPath.set(cwd, {
+          cwd,
+          firstSeenMs: record.timestampMs,
+          order
+        });
+      } else {
+        existing.firstSeenMs = Math.min(
+          existing.firstSeenMs,
+          record.timestampMs
+        );
+      }
+    }
+  }
+  const repositories = [...repositoriesByName.values()].sort(
+    (left, right) => left.firstSeenMs - right.firstSeenMs || left.order - right.order
+  ).map(({ order: _order, ...relationship }) => relationship);
+  const cwds = [...cwdsByPath.values()].sort(
+    (left, right) => left.firstSeenMs - right.firstSeenMs || left.order - right.order
+  ).map(({ order: _order, ...relationship }) => relationship);
+  return {
+    sessionId: first.sessionId,
+    target: first.target,
+    startedAtMs,
+    createdAt: startedAtMs,
+    machine: "local",
+    ...firstPrompt ? { firstPrompt } : {},
+    ...repositories.length > 0 ? { repositories } : {},
+    ...cwds.length > 0 ? { cwds } : {}
+  };
+}
+function batchesForSession(events) {
+  const batches = [];
+  let batch = [];
+  let batchBytes = 0;
+  let repositories = /* @__PURE__ */ new Set();
+  let cwds = /* @__PURE__ */ new Set();
+  for (const event of events) {
+    const repository = typeof event.row.repository === "string" ? event.row.repository : void 0;
+    const cwd = typeof event.row.cwd === "string" ? event.row.cwd : void 0;
+    const nextRelationshipCount = repositories.size + cwds.size + (repository && !repositories.has(repository) ? 1 : 0) + (cwd && !cwds.has(cwd) ? 1 : 0);
+    const exceedsSessionRowLimit = batch.length > 0 && utf8Bytes(
+      serializedJson(hookSessionRow([...batch, event]), "Hook session row")
+    ) > MAX_SESSION_ROW_JSON_BYTES;
+    if (batch.length > 0 && (batch.length >= 100 || batchBytes + event.jsonBytes > MAX_BATCH_JSON_BYTES || nextRelationshipCount > MAX_SESSION_RELATIONSHIPS_PER_ROW || exceedsSessionRowLimit)) {
+      batches.push(batch);
+      batch = [];
+      batchBytes = 0;
+      repositories = /* @__PURE__ */ new Set();
+      cwds = /* @__PURE__ */ new Set();
+    }
+    batch.push(event);
+    batchBytes += event.jsonBytes;
+    if (repository) repositories.add(repository);
+    if (cwd) cwds.add(cwd);
+  }
+  if (batch.length > 0) batches.push(batch);
+  return batches;
+}
+function groupPendingEvents(events) {
+  const bySession = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const session = bySession.get(event.record.sessionId) ?? [];
+    session.push(event);
+    bySession.set(event.record.sessionId, session);
+  }
+  return [...bySession.values()].flatMap(batchesForSession);
+}
+function activeHookDestinationSnapshot() {
+  const environment = getActiveEnv();
+  const destinationIdentity = getSyncDestinationIdentity(environment.name);
+  if (!destinationIdentity) {
+    return { kind: "unauthenticated", environment: environment.name };
+  }
+  return {
+    kind: "ready",
+    binding: {
+      environment: environment.name,
+      targetUrl: getSiteUrlForConvexUrl(environment.convexUrl),
+      destinationIdentity
+    }
+  };
+}
+function getActiveHookDestinationBinding() {
+  const snapshot = activeHookDestinationSnapshot();
+  return snapshot.kind === "ready" ? snapshot.binding : null;
+}
+function sameDestinationBinding(left, right) {
+  return left.environment === right.environment && left.targetUrl === right.targetUrl && left.destinationIdentity === right.destinationIdentity;
+}
+async function resolveDestination() {
+  const initial = activeHookDestinationSnapshot();
+  if (initial.kind !== "ready") return initial;
+  const destination = initial.binding;
+  const token = await getValidToken({ env: destination.environment });
+  if (!token) {
+    return {
+      kind: "unauthenticated",
+      environment: destination.environment
+    };
+  }
+  const verified = activeHookDestinationSnapshot();
+  if (verified.kind !== "ready" || !sameDestinationBinding(destination, verified.binding)) {
+    return verified.kind === "ready" ? { kind: "unauthenticated", environment: verified.binding.environment } : verified;
+  }
+  return {
+    kind: "ready",
+    destination: {
+      ...destination,
+      authorization: token.startsWith("Bearer ") ? token : `Bearer ${token}`
+    }
+  };
+}
+async function runHookSyncCycle(opts) {
+  const nowMs = opts.nowMs ?? Date.now;
+  const totalPending = opts.database.countPendingHookEvents();
+  if (totalPending === 0) {
+    return { kind: "drained", pending: 0, uploaded: 0 };
+  }
+  if (opts.signal?.aborted) throw abortReason(opts.signal);
+  const destinationResolution = await abortable(
+    resolveDestination(),
+    opts.signal
+  );
+  if (destinationResolution.kind !== "ready") {
+    return {
+      kind: destinationResolution.kind,
+      environment: destinationResolution.environment,
+      pending: opts.database.countPendingHookEvents(),
+      uploaded: 0
+    };
+  }
+  const destination = destinationResolution.destination;
+  const claimedAtMs = nowMs();
+  const pendingRecords = opts.database.claimPendingHookEvents(
+    destination,
+    100,
+    claimedAtMs
+  );
+  if (pendingRecords.length === 0) {
+    const retryAtMs2 = opts.database.nextPendingHookAttemptAtMs(destination);
+    if (retryAtMs2 !== void 0 && retryAtMs2 > claimedAtMs) {
+      return {
+        kind: "completed",
+        environment: destination.environment,
+        pending: opts.database.countPendingHookEvents(),
+        uploaded: 0,
+        error: "Hook events are waiting for their authorization retry",
+        retryAtMs: retryAtMs2
+      };
+    }
+    return {
+      kind: "destination_drained",
+      environment: destination.environment,
+      pending: opts.database.countPendingHookEvents(),
+      uploaded: 0
+    };
+  }
+  let uploaded = 0;
+  let quarantined = 0;
+  let lastError;
+  let transportRetryAtMs;
+  let blockedByTransportFailure = false;
+  const deferredSessionRetryAtMs = /* @__PURE__ */ new Map();
+  const deferRetryableRecords = (records, error, notBeforeMs) => {
+    if (records.length === 0) return void 0;
+    lastError = error;
+    const retryAtMs2 = Math.max(
+      nowMs() + retryDelayForRecords(records),
+      notBeforeMs ?? 0
+    );
+    const deferred = opts.database.deferHookEvents(
+      destination,
+      records.map((record) => record.syncId),
+      retryAtMs2
+    );
+    return deferred === 0 ? void 0 : retryAtMs2;
+  };
+  const deferUnattemptedSessionTail = (events, attemptedIndex, retryAtMs2) => {
+    const syncIds = events.slice(attemptedIndex + 1).map((event) => event.record.syncId);
+    if (syncIds.length === 0) return;
+    opts.database.deferHookEvents(destination, syncIds, retryAtMs2);
+  };
+  const preparedEvents = [];
+  for (const record of pendingRecords) {
+    if (opts.signal?.aborted) throw abortReason(opts.signal);
+    try {
+      preparedEvents.push(await prepareHookEvent(record, opts.signal));
+    } catch (error) {
+      if (opts.signal?.aborted) throw abortReason(opts.signal);
+      quarantined += opts.database.quarantineHookEvents(
+        destination,
+        [
+          {
+            syncId: record.syncId,
+            reason: rejectionReason("local_serialization_error", error)
+          }
+        ],
+        nowMs()
+      );
+    }
+  }
+  eventGroups: for (const events of groupPendingEvents(preparedEvents)) {
+    if (opts.signal?.aborted) throw abortReason(opts.signal);
+    const records = events.map((event) => event.record);
+    const sessionId = records[0].sessionId;
+    const deferredSessionRetry = deferredSessionRetryAtMs.get(sessionId);
+    if (deferredSessionRetry !== void 0) {
+      opts.database.deferHookEvents(
+        destination,
+        records.map((record) => record.syncId),
+        deferredSessionRetry
+      );
+      continue;
+    }
+    const requestOptions = {
+      version: opts.version,
+      ...opts.signal ? { signal: opts.signal } : {},
+      ...opts.fetch ? { fetch: opts.fetch } : {},
+      nowMs
+    };
+    let sessionRow;
+    try {
+      sessionRow = hookSessionRow(events);
+      const sessionRowBytes = utf8Bytes(
+        serializedJson(sessionRow, "Hook session row")
+      );
+      if (sessionRowBytes > MAX_SESSION_ROW_JSON_BYTES) {
+        throw new Error(
+          `Hook session row exceeds ${MAX_SESSION_ROW_JSON_BYTES} UTF-8 bytes`
+        );
+      }
+    } catch (error) {
+      quarantined += opts.database.quarantineHookEvents(
+        destination,
+        records.map((record) => ({
+          syncId: record.syncId,
+          reason: rejectionReason("session_serialization_error", error)
+        })),
+        nowMs()
+      );
+      continue;
+    }
+    const sessionResponse = await postSyncRows(
+      destination,
+      "sessions",
+      [sessionRow],
+      requestOptions
+    );
+    if (sessionResponse.status === 401) {
+      return {
+        kind: "unauthenticated",
+        environment: destination.environment,
+        pending: opts.database.countPendingHookEvents(),
+        uploaded
+      };
+    }
+    if (!sessionResponse.ok) {
+      if (terminalHttpStatus(sessionResponse.status)) {
+        const retryAtMs2 = deferRetryableRecords(
+          records,
+          rejectionReason(
+            `session_upload_rejected_http_${sessionResponse.status}`,
+            sessionResponse.error ?? "request rejected"
+          )
+        );
+        if (retryAtMs2 !== void 0) {
+          deferredSessionRetryAtMs.set(sessionId, retryAtMs2);
+        }
+        continue;
+      }
+      const error = sessionResponse.error ?? "Session sync request failed";
+      transportRetryAtMs = deferRetryableRecords(
+        records,
+        error,
+        sessionResponse.retryAtMs
+      );
+      if (perGroupServerFailure(sessionResponse.status)) {
+        if (transportRetryAtMs !== void 0) {
+          deferredSessionRetryAtMs.set(sessionId, transportRetryAtMs);
+        }
+        continue;
+      }
+      blockedByTransportFailure = true;
+      break;
+    }
+    const sessionReceipt = sessionAcceptance(
+      sessionResponse.body,
+      records[0].sessionId
+    );
+    if (!sessionReceipt.ok) {
+      const retryAtMs2 = deferRetryableRecords(records, sessionReceipt.error);
+      if (retryAtMs2 !== void 0) {
+        deferredSessionRetryAtMs.set(sessionId, retryAtMs2);
+      }
+      continue;
+    }
+    if (!sessionReceipt.accepted) {
+      const retryAtMs2 = deferRetryableRecords(
+        records,
+        `Server has not accepted session ${records[0].sessionId}; retrying after authorization refresh`
+      );
+      if (retryAtMs2 !== void 0) {
+        deferredSessionRetryAtMs.set(sessionId, retryAtMs2);
+      }
+      continue;
+    }
+    const hookResponse = await postSyncRows(
+      destination,
+      "hook_events",
+      events.map((event) => event.row),
+      requestOptions
+    );
+    if (hookResponse.status === 401) {
+      return {
+        kind: "unauthenticated",
+        environment: destination.environment,
+        pending: opts.database.countPendingHookEvents(),
+        uploaded
+      };
+    }
+    if (!hookResponse.ok) {
+      if (terminalHttpStatus(hookResponse.status)) {
+        if (events.length > 1) {
+          for (const [eventIndex, event] of events.entries()) {
+            const isolatedResponse = await postSyncRows(
+              destination,
+              "hook_events",
+              [event.row],
+              requestOptions
+            );
+            if (isolatedResponse.status === 401) {
+              return {
+                kind: "unauthenticated",
+                environment: destination.environment,
+                pending: opts.database.countPendingHookEvents(),
+                uploaded
+              };
+            }
+            if (isolatedResponse.ok) {
+              const acceptance2 = hookAcceptance(isolatedResponse.body, [
+                event.record
+              ]);
+              if (!acceptance2.ok) {
+                const retryAtMs2 = deferRetryableRecords(
+                  [event.record],
+                  acceptance2.error
+                );
+                if (retryAtMs2 !== void 0) {
+                  deferredSessionRetryAtMs.set(sessionId, retryAtMs2);
+                  deferUnattemptedSessionTail(events, eventIndex, retryAtMs2);
+                }
+                continue eventGroups;
+              }
+              if (acceptance2.acceptedSyncIds.length > 0) {
+                opts.database.acknowledgeHookEvents(
+                  destination,
+                  acceptance2.acceptedSyncIds
+                );
+                uploaded += acceptance2.acceptedSyncIds.length;
+              }
+              if (acceptance2.omittedSyncIds.length > 0) {
+                const retryAtMs2 = deferRetryableRecords(
+                  [event.record],
+                  omittedHookReceiptError(acceptance2.omittedSyncIds.length)
+                );
+                if (retryAtMs2 !== void 0) {
+                  deferredSessionRetryAtMs.set(sessionId, retryAtMs2);
+                  deferUnattemptedSessionTail(events, eventIndex, retryAtMs2);
+                }
+                continue eventGroups;
+              }
+              continue;
+            }
+            if (terminalHttpStatus(isolatedResponse.status)) {
+              quarantined += opts.database.quarantineHookEvents(
+                destination,
+                [
+                  {
+                    syncId: event.record.syncId,
+                    reason: rejectionReason(
+                      `hook_upload_rejected_http_${isolatedResponse.status}`,
+                      isolatedResponse.error ?? "request rejected"
+                    )
+                  }
+                ],
+                nowMs()
+              );
+              continue;
+            }
+            const error2 = isolatedResponse.error ?? "Hook sync request failed";
+            transportRetryAtMs = deferRetryableRecords(
+              [event.record],
+              error2,
+              isolatedResponse.retryAtMs
+            );
+            if (perGroupServerFailure(isolatedResponse.status)) {
+              if (transportRetryAtMs !== void 0) {
+                deferredSessionRetryAtMs.set(sessionId, transportRetryAtMs);
+                deferUnattemptedSessionTail(
+                  events,
+                  eventIndex,
+                  transportRetryAtMs
+                );
+              }
+              continue eventGroups;
+            }
+            blockedByTransportFailure = true;
+            break eventGroups;
+          }
+          continue;
+        }
+        quarantined += opts.database.quarantineHookEvents(
+          destination,
+          records.map((record) => ({
+            syncId: record.syncId,
+            reason: rejectionReason(
+              `hook_upload_rejected_http_${hookResponse.status}`,
+              hookResponse.error ?? "request rejected"
+            )
+          })),
+          nowMs()
+        );
+        continue;
+      }
+      const error = hookResponse.error ?? "Hook sync request failed";
+      transportRetryAtMs = deferRetryableRecords(
+        records,
+        error,
+        hookResponse.retryAtMs
+      );
+      if (perGroupServerFailure(hookResponse.status)) {
+        if (transportRetryAtMs !== void 0) {
+          deferredSessionRetryAtMs.set(sessionId, transportRetryAtMs);
+        }
+        continue;
+      }
+      blockedByTransportFailure = true;
+      break;
+    }
+    const acceptance = hookAcceptance(hookResponse.body, records);
+    if (!acceptance.ok) {
+      const retryAtMs2 = deferRetryableRecords(records, acceptance.error);
+      if (retryAtMs2 !== void 0) {
+        deferredSessionRetryAtMs.set(sessionId, retryAtMs2);
+      }
+      continue;
+    }
+    if (acceptance.acceptedSyncIds.length > 0) {
+      opts.database.acknowledgeHookEvents(
+        destination,
+        acceptance.acceptedSyncIds
+      );
+      uploaded += acceptance.acceptedSyncIds.length;
+    }
+    if (acceptance.omittedSyncIds.length > 0) {
+      const omittedSyncIds = new Set(acceptance.omittedSyncIds);
+      const retryAtMs2 = deferRetryableRecords(
+        records.filter((record) => omittedSyncIds.has(record.syncId)),
+        omittedHookReceiptError(acceptance.omittedSyncIds.length)
+      );
+      if (retryAtMs2 !== void 0) {
+        deferredSessionRetryAtMs.set(sessionId, retryAtMs2);
+      }
+    }
+  }
+  const nextPendingAttemptAtMs = opts.database.nextPendingHookAttemptAtMs(destination);
+  const nextRetryAtMs = blockedByTransportFailure ? transportRetryAtMs : nextPendingAttemptAtMs === void 0 ? void 0 : Math.max(nextPendingAttemptAtMs, nowMs());
+  return {
+    kind: "completed",
+    environment: destination.environment,
+    pending: opts.database.countPendingHookEvents(),
+    uploaded,
+    ...quarantined > 0 ? { quarantined } : {},
+    ...lastError ? { error: lastError } : {},
+    ...nextRetryAtMs === void 0 ? {} : { retryAtMs: nextRetryAtMs },
+    ...blockedByTransportFailure ? { wakeOnCapture: false } : {}
+  };
+}
+function createHookSyncLoop(opts) {
+  const nowMs = opts.nowMs ?? Date.now;
+  const runOnce = opts.runOnce ?? runHookSyncCycle;
+  let stopping = false;
+  let wakePending = false;
+  let forceWakePending = false;
+  let wakeWaiter = null;
+  let activeAbort = null;
+  let failures = 0;
+  let status = {
+    phase: "idle",
+    pending: opts.database.countPendingHookEvents()
+  };
+  const wake = (force = false) => {
+    wakePending = true;
+    forceWakePending ||= force;
+    wakeWaiter?.(stopping || force);
+  };
+  const wait = async (delayMs, wakeOnCapture = true) => {
+    if (stopping || forceWakePending || wakePending && wakeOnCapture) {
+      wakePending = false;
+      forceWakePending = false;
+      return;
+    }
+    if (!wakeOnCapture) wakePending = false;
+    await new Promise((resolve) => {
+      const finish = () => {
+        clearTimeout(timer);
+        wakeWaiter = null;
+        wakePending = false;
+        forceWakePending = false;
+        resolve();
+      };
+      const timer = setTimeout(() => {
+        finish();
+      }, delayMs);
+      wakeWaiter = (force) => {
+        if (!force && !wakeOnCapture) return;
+        finish();
+      };
+    });
+  };
+  const done = (async () => {
+    while (!stopping) {
+      const attemptedAtMs = nowMs();
+      status = {
+        ...status,
+        phase: "syncing",
+        pending: opts.database.countPendingHookEvents(),
+        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)
+        );
+        const nextAttemptAtMs = nowMs() + delayMs2;
+        status = {
+          phase: "backing_off",
+          pending: opts.database.countPendingHookEvents(),
+          lastAttemptAtMs: attemptedAtMs,
+          lastError: error instanceof Error ? error.message : String(error),
+          nextAttemptAtMs
+        };
+        await wait(delayMs2, false);
+        continue;
+      }
+      activeAbort = null;
+      if (stopping) break;
+      const completedAtMs = nowMs();
+      const succeeded = result.kind === "drained" || result.kind === "destination_drained" || result.uploaded > 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" ? AUTH_INTERVAL_MS : result.kind === "completed" && result.pending > 0 ? result.retryAtMs !== void 0 ? Math.max(
+        MIN_RETRY_INTERVAL_MS,
+        result.retryAtMs - completedAtMs
+      ) : result.error ? failureDelay : MIN_RETRY_INTERVAL_MS : IDLE_INTERVAL_MS;
+      status = {
+        phase: result.kind === "unauthenticated" ? "waiting_for_auth" : 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"
+        } : {},
+        nextAttemptAtMs: completedAtMs + delayMs
+      };
+      await wait(
+        delayMs,
+        result.kind !== "unauthenticated" && (result.kind !== "completed" || result.wakeOnCapture !== false)
+      );
+    }
+  })();
+  return {
+    done,
+    wake,
+    stop: () => {
+      if (stopping) return;
+      stopping = true;
+      activeAbort?.abort();
+      wake(true);
+    },
+    status: () => status
+  };
+}
+
+export {
+  getActiveHookDestinationBinding,
+  createHookSyncLoop
+};