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

package/dist/chunk-CK5MEL5J.js

@@ -0,0 +1,140 @@
+import {
+  resolvePackageRoot,
+  runRawSyncOnce
+} from "./chunk-JXSSPQ5B.js";
+
+// src/observer/sync-cycle.ts
+import { fork } from "child_process";
+import path from "path";
+var ObserverSyncCycleAbortedError = class extends Error {
+  constructor() {
+    super("observer sync cycle aborted");
+  }
+};
+function abortableFetch(signal) {
+  return (input, init) => {
+    const requestSignal = init?.signal;
+    return fetch(input, {
+      ...init,
+      signal: requestSignal ? AbortSignal.any([signal, requestSignal]) : signal
+    });
+  };
+}
+async function runObserverSyncCycle(signal) {
+  const attempt = await runRawSyncOnce({
+    continuous: true,
+    ...signal ? { fetch: abortableFetch(signal) } : {}
+  });
+  if (attempt.kind === "disabled") return { kind: "disabled" };
+  if (attempt.kind === "unauthenticated") {
+    return {
+      kind: "unauthenticated",
+      environment: attempt.environment
+    };
+  }
+  return {
+    kind: "completed",
+    environment: attempt.environment,
+    outcome: attempt.result.outcome,
+    uploadedBytes: attempt.result.upload.uploadedBytes,
+    failed: attempt.result.upload.failed,
+    exhausted: attempt.result.upload.exhausted,
+    retryAtMs: attempt.result.upload.retryAtMs,
+    nextRetryAtMs: attempt.result.upload.nextRetryAtMs
+  };
+}
+function isSyncOutcome(value) {
+  return value === "drained" || value === "pending" || value === "backing_off" || value === "busy" || value === "throttled" || value === "failed" || value === "exhausted";
+}
+function parseObserverSyncCycleResult(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const record = value;
+  if (record.kind === "disabled") return { kind: "disabled" };
+  if (record.kind === "unauthenticated" && typeof record.environment === "string") {
+    return { kind: "unauthenticated", environment: record.environment };
+  }
+  if (record.kind !== "completed" || typeof record.environment !== "string" || !isSyncOutcome(record.outcome) || typeof record.uploadedBytes !== "number" || typeof record.failed !== "number" || typeof record.exhausted !== "number" || record.retryAtMs !== void 0 && typeof record.retryAtMs !== "number" || record.nextRetryAtMs !== void 0 && typeof record.nextRetryAtMs !== "number") {
+    return null;
+  }
+  return {
+    kind: "completed",
+    environment: record.environment,
+    outcome: record.outcome,
+    uploadedBytes: record.uploadedBytes,
+    failed: record.failed,
+    exhausted: record.exhausted,
+    ...typeof record.retryAtMs === "number" ? { retryAtMs: record.retryAtMs } : {},
+    ...typeof record.nextRetryAtMs === "number" ? { nextRetryAtMs: record.nextRetryAtMs } : {}
+  };
+}
+function runObserverSyncCycleSubprocess(opts = {}) {
+  if (opts.signal?.aborted) {
+    return Promise.reject(new ObserverSyncCycleAbortedError());
+  }
+  const scriptPath = opts.scriptPath ?? path.join(resolvePackageRoot(), "dist", "sync-cycle.js");
+  return new Promise((resolve, reject) => {
+    const child = fork(scriptPath, [], {
+      detached: false,
+      env: process.env,
+      execPath: process.execPath,
+      silent: false,
+      stdio: ["ignore", "inherit", "inherit", "ipc"]
+    });
+    let result = null;
+    let settled = false;
+    let forceKillTimer = null;
+    const cleanup = () => {
+      opts.signal?.removeEventListener("abort", abort);
+      if (forceKillTimer) clearTimeout(forceKillTimer);
+    };
+    const finishReject = (error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(error);
+    };
+    const abort = () => {
+      try {
+        child.kill("SIGTERM");
+        forceKillTimer = setTimeout(() => {
+          try {
+            child.kill("SIGKILL");
+          } catch {
+          }
+        }, 2e3);
+        forceKillTimer.unref();
+      } catch {
+      }
+    };
+    opts.signal?.addEventListener("abort", abort, { once: true });
+    child.once("error", finishReject);
+    child.on("message", (message) => {
+      const parsed = parseObserverSyncCycleResult(message);
+      if (parsed) result = parsed;
+    });
+    child.once("exit", (code, signal) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      if (opts.signal?.aborted) {
+        reject(new ObserverSyncCycleAbortedError());
+        return;
+      }
+      if (code !== 0 || !result) {
+        reject(
+          new Error(
+            `observer sync cycle exited code=${code ?? "null"} signal=${signal ?? "null"}`
+          )
+        );
+        return;
+      }
+      resolve(result);
+    });
+  });
+}
+
+export {
+  ObserverSyncCycleAbortedError,
+  runObserverSyncCycle,
+  runObserverSyncCycleSubprocess
+};