@expo/event-log 0.0.1-init

package/dist/event-log.js

@@ -0,0 +1,983 @@
+Object.defineProperty(exports, "__esModule", {
+  value: !0
+});
+
+var e = require("node:path");
+
+var t = require("node:perf_hooks");
+
+var i = require("./chunks/tap-chunk.js");
+
+var n = require("node:buffer");
+
+var s = require("node:events");
+
+var r = require("node:fs");
+
+var o = require("node:net");
+
+var c = require("node:readline");
+
+var h = require("node:worker_threads");
+
+const l = Symbol.for(`@expo/event-log/state-${i.EVENT_LOG_STATE_VERSION}`);
+
+const a = function getEventLogState() {
+  const e = globalThis;
+  return e[l] ??= {
+    logPath: process.cwd(),
+    eventLoggerInfo: null
+  };
+}();
+
+function setLogPath(e) {
+  a.logPath = e;
+}
+
+function setPrimarySink(e) {
+  a.primarySink = e;
+}
+
+function setEventLoggerInfo(e) {
+  a.eventLoggerInfo = e;
+}
+
+function writeRawLine(e) {
+  const t = e.endsWith("\n") ? e : `${e}\n`;
+  a.primarySink?._writeln(t);
+}
+
+const f = 16387;
+
+const d = t.performance.timeOrigin;
+
+let u;
+
+let p = "";
+
+function writeEvent(e, t, i, n, s) {
+  e._writeln(function serializeEvent(e, t, i, n, s) {
+    const r = getEventTimestamp();
+    if (!n?._w) {
+      const n = i ? JSON.stringify(i).slice(1) : "";
+      return n.length > 1 ? `{"_e":"${e}:${t}","_t":${r},${n}\n` : `{"_e":"${e}:${t}","_t":${r}}\n`;
+    }
+    let o = `{"_e":"${e}:${t}","_t":${r}`;
+    if (n?._w) {
+      o += `,"_w":${stringifyWorkerId(n._w)}`;
+    }
+    return `${appendPayload(o, i)}}\n`;
+  }(t, i, n, s));
+}
+
+function writeCompleteEvent(e, t, i, n, s, r, o) {
+  let c = `{"_e":"${t}:${i}","_t":${getEventTimestamp()},"_d":${r}`;
+  if (o?._w) {
+    c += `,"_w":${stringifyWorkerId(o._w)}`;
+  }
+  e._writeln(`${function appendMergedPayload(e, t, i) {
+    if (!t) {
+      return appendPayload(e, i);
+    }
+    if (!i) {
+      return appendPayload(e, t);
+    }
+    const n = new Set(Object.keys(i));
+    for (const i of Object.keys(t)) {
+      if (n.has(i)) {
+        continue;
+      }
+      const s = JSON.stringify(t[i]);
+      if (void 0 !== s) {
+        e += `,${JSON.stringify(i)}:${s}`;
+      }
+    }
+    return appendPayload(e, i);
+  }(c, n, s)}}\n`);
+}
+
+function getEventTimestamp() {
+  return d + t.performance.now();
+}
+
+function stringifyWorkerId(e) {
+  if (e !== u) {
+    u = e;
+    p = JSON.stringify(e);
+  }
+  return p;
+}
+
+function appendPayload(e, t) {
+  if (!t) {
+    return e;
+  }
+  const i = JSON.stringify(t);
+  return i && i.length > 2 ? `${e},${i.slice(1, -1)}` : e;
+}
+
+class LogStream extends s.EventEmitter {
+  #e=-1;
+  #t=null;
+  #i=null;
+  #n=!0;
+  #s=!1;
+  #r=!1;
+  #o=!1;
+  #c=!1;
+  #h=!1;
+  #l=!1;
+  #a="";
+  #f=0;
+  #d=[];
+  #u=0;
+  #p=0;
+  #g=(e, t) => this.#y(e, t);
+  constructor(e, t = {}) {
+    super();
+    this.#n = !1 !== t.closeFd;
+    if ("number" == typeof e) {
+      try {
+        r.fsyncSync(e);
+      } catch {}
+      this.#e = e;
+      process.nextTick(() => this.emit("ready"));
+    } else if ("string" == typeof e) {
+      this.#S(e);
+    }
+  }
+  get file() {
+    return this.#t;
+  }
+  get fd() {
+    return this.#e;
+  }
+  get writing() {
+    return this.#s;
+  }
+  get writable() {
+    return !this.#c && !this.#r;
+  }
+  reopen(e = this.#t) {
+    if (null == this.#t) {
+      throw new Error("Cannot reopen an fd-only LogStream");
+    }
+    if (this.#c || this.#r) {
+      return;
+    }
+    if (e) {
+      this.#t = e;
+    }
+    if (this.#h) {
+      this.once("ready", () => this.reopen(e));
+      return;
+    }
+    this.#l = !0;
+    if (!this.#s) {
+      this.#m();
+    }
+  }
+  #m() {
+    if (null == this.#t) {
+      return;
+    }
+    this.#l = !1;
+    this.#i = this.#e;
+    this.#S(this.#t);
+  }
+  #y(e, t) {
+    if (e) {
+      if ("EAGAIN" === e.code || "EBUSY" === e.code) {
+        setTimeout(() => this.#w(), 100);
+      } else {
+        this.#s = !1;
+        this.emit("error", e);
+      }
+    } else {
+      this.emit("write", t);
+      if (t === this.#a.length) {
+        this.#f -= this.#a.length;
+        this.#a = "";
+        if (this.#d.length - this.#u > this.#p) {
+          this.#w();
+        } else if (this.#l) {
+          this.#s = !1;
+          this.#m();
+        } else if (this.#r) {
+          this.#s = !1;
+          this.#v();
+        } else {
+          this.#s = !1;
+          if (this.#o) {
+            this.emit("drain");
+          }
+        }
+      } else {
+        if (n.Buffer.byteLength(this.#a) > t) {
+          const e = n.Buffer.from(this.#a).toString("utf8", t);
+          this.#f -= this.#a.length - e.length;
+          this.#a = e;
+        } else {
+          this.#f -= this.#a.length;
+          this.#a = "";
+        }
+        if (this.#a || this.#d.length - this.#u > this.#p) {
+          this.#w();
+        } else if (this.#l) {
+          this.#s = !1;
+          this.#m();
+        } else if (this.#r) {
+          this.#s = !1;
+          this.#v();
+        } else {
+          this.#s = !1;
+          if (this.#o) {
+            this.emit("drain");
+          }
+        }
+      }
+    }
+  }
+  #S(t) {
+    this.#h = !0;
+    this.#s = !0;
+    const onOpened = (e, i) => {
+      const n = this.#i;
+      this.#i = null;
+      if (e) {
+        this.#s = !1;
+        this.#h = !1;
+        this.emit("error", e);
+      } else {
+        this.#e = i;
+        this.#t = t;
+        this.#h = !1;
+        this.#s = !1;
+        this.emit("ready");
+        if (null != n && n !== this.#e && !isStdFd(n)) {
+          fsFsync(n, () => r.close(n, () => {}));
+        }
+        if (this.#c) {} else if (!this.writing && this.#d.length - this.#u > this.#p || this.#o) {
+          this.#w();
+        }
+      }
+    };
+    r.mkdir(e.dirname(t), {
+      recursive: !0
+    }, e => {
+      if (e) {
+        return onOpened(e);
+      }
+      r.open(t, "a", 438, onOpened);
+    });
+  }
+  #v() {
+    if (-1 === this.#e) {
+      this.once("ready", () => this.#v());
+      return;
+    }
+    this.#c = !0;
+    this.#p = 0;
+    this.#d.length = 0;
+    this.#u = 0;
+    const onClose = e => {
+      if (e) {
+        this.emit("error", e);
+        this.emit("close", e);
+      } else {
+        if (this.#r && !this.#s) {
+          this.emit("finish");
+        }
+        this.emit("close");
+      }
+    };
+    fsFsync(this.#e, e => {
+      if (!e && this.#n && !isStdFd(this.#e)) {
+        r.close(this.#e, onClose);
+      } else {
+        onClose();
+      }
+    });
+  }
+  #w() {
+    this.#s = !0;
+    if (!this.#a) {
+      const e = this.#d.length - this.#p;
+      if (e > this.#u) {
+        this.#a = this.#d[this.#u++] || "";
+        while (this.#u < e && this.#a.length < f) {
+          this.#a += this.#d[this.#u++];
+        }
+        if (this.#u === this.#d.length) {
+          this.#d.length = 0;
+          this.#u = 0;
+        }
+      }
+    }
+    r.write(this.#e, this.#a, this.#g);
+  }
+  _end() {
+    if (!this.#c && !this.#r) {
+      this.#r = !0;
+      if (this.#h) {
+        this.once("ready", () => this._end());
+      } else if (!this.#s && this.#e >= 0) {
+        if (this.#d.length - this.#u > this.#p) {
+          this.#w();
+        } else {
+          this.#v();
+        }
+      }
+    }
+    return this;
+  }
+  end(e, t, i) {
+    const n = i || t || e;
+    const s = "function" != typeof e ? e : void 0;
+    const r = "function" == typeof n ? n : void 0;
+    if ("string" == typeof s) {
+      this.write(s, "string" == typeof t ? t : "utf8");
+    } else if (null != s) {
+      this.write(s);
+    }
+    if (r) {
+      this.once("close", r);
+    }
+    return this._end();
+  }
+  destroy() {
+    if (!this.#c) {
+      this.#v();
+    }
+  }
+  flush(e) {
+    if (this.#c) {
+      e?.();
+    } else {
+      const onDrain = () => {
+        if (!this.#c) {
+          fsFsync(this.#e, t => {
+            this.#o = !1;
+            if ("EBADF" === t?.code) {
+              e?.();
+            } else {
+              e?.(t);
+            }
+          });
+        } else {
+          this.#o = !1;
+          e?.();
+        }
+        this.off("error", onError);
+      };
+      const onError = t => {
+        this.#o = !1;
+        this.off("drain", onDrain);
+        e?.(t);
+      };
+      this.#o = !0;
+      this.once("drain", onDrain);
+      this.once("error", onError);
+      if (!this.#s) {
+        if (this.#d.length - this.#u > this.#p || this.#a) {
+          this.#w();
+        } else {
+          process.nextTick(() => this.emit("drain"));
+        }
+      }
+    }
+  }
+  _writeln(e) {
+    this.#f += e.length;
+    if (!this.#s && this.#d.length === this.#u && !this.#a) {
+      this.#s = !0;
+      this.#a = e;
+      r.write(this.#e, e, this.#g);
+    } else {
+      this.#d.push(e);
+      if (!this.#s) {
+        this.#w();
+      }
+    }
+    return this.#f < f;
+  }
+  _write(e) {
+    if (this.#c) {
+      return !1;
+    }
+    if (0 === this.#p && 10 === e.charCodeAt(e.length - 1)) {
+      return this._writeln(e);
+    }
+    this.#f += e.length;
+    let t = 0;
+    let i = -1;
+    while ((i = e.indexOf("\n", t)) > -1) {
+      const n = e.slice(t, i + 1);
+      if (this.#p > 0) {
+        this.#d[this.#d.length - 1] += n;
+      } else {
+        this.#d.push(n);
+      }
+      this.#p = 0;
+      t = ++i;
+    }
+    if (t < e.length) {
+      const i = e.slice(t);
+      if (this.#p > 0) {
+        this.#d[this.#d.length - 1] += i;
+      } else {
+        this.#d.push(e.slice(t));
+      }
+      this.#p = 1;
+    }
+    if (!this.#s && this.#d.length - this.#u > this.#p) {
+      this.#w();
+    }
+    return this.#f < f;
+  }
+  write(e, t, i) {
+    const s = i || t;
+    const r = "string" == typeof t ? t : "utf8";
+    const o = "string" == typeof e ? e : n.Buffer.from(e).toString(r);
+    const c = "function" == typeof s ? s : void 0;
+    try {
+      return this._write(o);
+    } finally {
+      c?.();
+    }
+  }
+  [Symbol.dispose]() {
+    this.destroy();
+  }
+}
+
+class WritableStreamSink {
+  constructor(e) {
+    this.stream = e;
+  }
+  get writable() {
+    return !1 !== this.stream.writable;
+  }
+  _writeln(e) {
+    return this.stream.write(e);
+  }
+  end(e) {
+    this.stream.end(e);
+    return this;
+  }
+  destroy() {
+    const e = this.stream;
+    e.destroy?.();
+  }
+}
+
+const isStdFd = e => {
+  switch (e) {
+   case 1:
+   case 2:
+   case process.stdout.fd:
+   case process.stderr.fd:
+    return !0;
+
+   default:
+    return !1;
+  }
+};
+
+const fsFsync = (e, t) => {
+  try {
+    r.fsync(e, t);
+  } catch (e) {
+    t(e);
+  }
+};
+
+const NOOP_DONE = () => {};
+
+function events(i) {
+  function log(e, t) {
+    if (a.primarySink) {
+      writeEvent(a.primarySink, i, e, t, a.eventMeta);
+    }
+  }
+  log.span = function span(e, n) {
+    if (!a.primarySink) {
+      return NOOP_DONE;
+    }
+    const s = t.performance.now();
+    return function done(e, r) {
+      if (!a.primarySink) {
+        return;
+      }
+      writeCompleteEvent(a.primarySink, i, e, n, r, t.performance.now() - s, a.eventMeta);
+    };
+  };
+  log.path = function relativePath(t) {
+    try {
+      return null != t && e.isAbsolute(t) ? e.relative(a.logPath, t).replace(/\\/g, "/") || "." : t ?? null;
+    } catch {
+      return t || null;
+    }
+  };
+  log.category = i;
+  return log;
+}
+
+const g = Symbol.for("@expo/event-log/process-origin");
+
+function setLocalProcessOrigin(e) {
+  const t = globalThis;
+  if (e) {
+    t[g] = e;
+  } else {
+    delete t[g];
+  }
+}
+
+function getProcessOrigin() {
+  if (!h.isMainThread) {
+    return {
+      kind: "worker_thread",
+      id: String(h.threadId)
+    };
+  }
+  const e = globalThis[g];
+  const t = process.env[i.INTERNAL_PROCESS_ORIGIN_ENV];
+  if (t && t !== e) {
+    return {
+      kind: "event_log_child",
+      id: t
+    };
+  }
+  if (process.env.NODE_UNIQUE_ID) {
+    return {
+      kind: "child_process",
+      id: process.env.NODE_UNIQUE_ID
+    };
+  }
+  return null;
+}
+
+class IpcSink {
+  #_=null;
+  #E=!1;
+  #c=!1;
+  #L=!1;
+  #d=[];
+  #k=Date.now();
+  #I;
+  #N;
+  constructor(e, t = {}) {
+    this.socketPath = e;
+    this.#I = t.retryMs ?? 50;
+    this.#N = t.maxRetryMs ?? 750;
+    this.#P();
+  }
+  get writable() {
+    return !this.#c;
+  }
+  _writeln(e) {
+    if (this.#c) {
+      return !1;
+    }
+    if (this.#E && this.#_) {
+      return this.#_.write(e);
+    }
+    this.#d.push(e);
+    return !1;
+  }
+  end(e) {
+    this.destroy();
+    e?.();
+    return this;
+  }
+  destroy() {
+    this.#c = !0;
+    this.#d.length = 0;
+    this.#_?.destroy();
+  }
+  #P() {
+    if (this.#c || this.#E) {
+      return;
+    }
+    if (Date.now() - this.#k > this.#N) {
+      this.destroy();
+      return;
+    }
+    const e = o.connect(this.socketPath);
+    this.#_ = e;
+    e.once("connect", () => {
+      this.#L = !1;
+      this.#E = !0;
+      for (const t of this.#d.splice(0)) {
+        e.write(t);
+      }
+    });
+    e.once("error", () => {
+      if (this.#E) {
+        return;
+      }
+      e.destroy();
+      this.#O();
+    });
+    e.once("close", () => {
+      if (this.#c) {
+        return;
+      }
+      this.#E = !1;
+      if (this.#_ === e) {
+        this.#_ = null;
+      }
+      this.#O();
+    });
+  }
+  #O() {
+    if (this.#L || this.#c) {
+      return;
+    }
+    this.#L = !0;
+    setTimeout(() => {
+      this.#L = !1;
+      this.#P();
+    }, this.#I);
+  }
+}
+
+const y = Symbol.for("@expo/event-log/process-cleanup");
+
+function getProcessCleanupState() {
+  const e = globalThis;
+  return e[y] ??= {
+    registered: !1,
+    callbacks: new Set
+  };
+}
+
+function runProcessCleanup() {
+  for (const e of getProcessCleanupState().callbacks) {
+    try {
+      e();
+    } catch {}
+  }
+}
+
+function listenUnixSocket(e, t) {
+  let i = !1;
+  let n = !1;
+  let s = !1;
+  const close = () => {
+    s = !0;
+    if (n && !i) {
+      e.close();
+    }
+  };
+  e.once("listening", () => {
+    n = !0;
+    if (s) {
+      close();
+    }
+  });
+  e.once("close", () => {
+    i = !0;
+    n = !1;
+  });
+  e.on("error", () => {
+    i = !0;
+    try {
+      e.close(() => {});
+    } catch {}
+  });
+  e.listen(t);
+  return close;
+}
+
+let S;
+
+const m = events("root");
+
+function parseLogTarget(t) {
+  if ("number" == typeof t) {
+    return Number.isSafeInteger(t) && t > 0 ? t : void 0;
+  }
+  if (!t) {
+    return;
+  }
+  const i = parseInt(t, 10);
+  if (`${i}` === t && i > 0 && Number.isSafeInteger(i)) {
+    return i;
+  }
+  try {
+    const i = e.parse(t);
+    const n = e.format(i);
+    setLogPath(i.dir || process.cwd());
+    return n;
+  } catch {
+    return;
+  }
+}
+
+function getInitMetadata(e) {
+  return {
+    format: "v0-jsonl",
+    formatVersion: i.EVENT_LOG_FORMAT_VERSION,
+    version: e ?? "UNVERSIONED",
+    processOrigin: getProcessOrigin() ?? void 0
+  };
+}
+
+function activateSink(e, t) {
+  setPrimarySink(e);
+  m("init", getInitMetadata(t));
+}
+
+function createSessionOrigin() {
+  const e = {
+    npmLifecycleEvent: process.env.npm_lifecycle_event,
+    npmExecPath: process.env.npm_execpath,
+    npmPackageName: process.env.npm_package_name
+  };
+  return {
+    argv: process.argv.slice(1),
+    execPath: process.execPath,
+    cwd: process.cwd(),
+    ppid: process.ppid || void 0,
+    env: Object.values(e).some(Boolean) ? e : void 0
+  };
+}
+
+exports.list = i.listSessions;
+
+exports.tap = i.tap;
+
+exports.events = events;
+
+exports.installEventLogger = function installEventLogger(t) {
+  if (a.primarySink) {
+    return;
+  }
+  const n = parseLogTarget(process.env[i.LOG_EVENTS_ENV]) ?? parseLogTarget("string" == typeof t || "number" == typeof t ? t : void 0);
+  if (null != n) {
+    if ("number" == typeof n) {
+      i.redirectConsoleForFd(n);
+    }
+    setEventLoggerInfo(function getExplicitTargetInfo(e) {
+      if ("number" == typeof e) {
+        return {
+          destination: 1 === e ? "stdout" : 2 === e ? "stderr" : "fd",
+          isUserVisibleOutput: 1 === e || 2 === e,
+          fd: e
+        };
+      }
+      return {
+        destination: "file",
+        isUserVisibleOutput: !1,
+        file: e
+      };
+    }(n));
+    activateSink(new LogStream(n));
+    return;
+  }
+  const s = process.env[i.INTERNAL_IPC_ENV];
+  if (s) {
+    !function connectToParent(e) {
+      const t = function getProcessWorkerId() {
+        const e = getProcessOrigin();
+        return e ? `${e.kind}:${e.id}` : void 0;
+      }();
+      if (t) {
+        !function setEventMeta(e) {
+          a.eventMeta = e;
+        }({
+          _w: t
+        });
+      }
+      const i = new IpcSink(e);
+      setPrimarySink(i);
+      setEventLoggerInfo({
+        destination: "ipc",
+        isUserVisibleOutput: !1
+      });
+      m("init", getInitMetadata());
+    }(s);
+    return;
+  }
+  if (t && "object" == typeof t) {
+    S = function createSession(t) {
+      i.cleanStaleSessionsSync();
+      const n = i.getSessionBaseDir();
+      const s = e.join(n, String(process.pid));
+      r.rmSync(s, {
+        recursive: !0,
+        force: !0
+      });
+      r.mkdirSync(s, {
+        recursive: !0
+      });
+      const h = t.maxSegments ?? i.DEFAULT_SEGMENTS;
+      const l = t.maxSegmentSize ?? i.DEFAULT_SEGMENT_SIZE;
+      const a = e.join(s, i.SESSION_FILES.liveSocket);
+      const f = e.join(s, i.SESSION_FILES.ipcSocket);
+      const d = new LogStream(e.join(s, "0.jsonl"));
+      const u = new Set;
+      let p = 0;
+      let g = !1;
+      d.on("write", t => {
+        p += t;
+        if (p < l) {
+          return;
+        }
+        p = 0;
+        !function rotateSegments(t, i) {
+          r.rmSync(e.join(t, i - 1 + ".jsonl"), {
+            force: !0
+          });
+          for (let n = i - 1; n >= 1; n--) {
+            const i = e.join(t, n - 1 + ".jsonl");
+            const s = e.join(t, `${n}.jsonl`);
+            try {
+              r.renameSync(i, s);
+            } catch {}
+          }
+        }(s, h);
+        d.reopen();
+      });
+      const y = o.createServer(e => {
+        const t = function createSocketSink(e) {
+          const t = e._handle?.fd;
+          if ("number" == typeof t && t >= 0) {
+            return new LogStream(t, {
+              closeFd: !1
+            });
+          }
+          return new WritableStreamSink(e);
+        }(e);
+        u.add(t);
+        e.on("close", () => {
+          u.delete(t);
+          t.destroy();
+        });
+        e.on("error", () => {
+          u.delete(t);
+          t.destroy();
+          e.destroy();
+        });
+      });
+      const S = o.createServer(e => {
+        const i = c.createInterface({
+          input: e
+        });
+        i.on("line", t.onWorkerLine);
+        e.on("close", () => i.close());
+        e.on("error", () => i.close());
+      });
+      const m = listenUnixSocket(y, a);
+      const w = listenUnixSocket(S, f);
+      const v = String(process.pid);
+      process.env[i.INTERNAL_IPC_ENV] = f;
+      process.env[i.INTERNAL_PROCESS_ORIGIN_ENV] = v;
+      setLocalProcessOrigin(v);
+      const _ = {
+        pid: process.pid,
+        formatVersion: i.EVENT_LOG_FORMAT_VERSION,
+        startedAt: Date.now(),
+        command: t.command ?? process.argv.slice(1).join(" "),
+        cwd: process.cwd(),
+        maxSegments: h,
+        version: t.version,
+        socket: i.SESSION_FILES.liveSocket,
+        ipcSocket: i.SESSION_FILES.ipcSocket,
+        origin: createSessionOrigin()
+      };
+      !function writeJsonAtomic(e, t) {
+        const i = `${e}.${process.pid}.tmp`;
+        r.writeFileSync(i, JSON.stringify(t, null, 2));
+        r.renameSync(i, e);
+      }(e.join(s, i.SESSION_FILES.meta), _);
+      const E = {
+        get writable() {
+          return d.writable;
+        },
+        get file() {
+          return d.file;
+        },
+        _writeln(e) {
+          const t = d._writeln(e);
+          for (const t of u) {
+            t._writeln(e);
+          }
+          return t;
+        },
+        end(e) {
+          d.end(e);
+          for (const e of u) {
+            e.end();
+          }
+          return this;
+        },
+        destroy() {
+          d.destroy();
+          for (const e of u) {
+            e.destroy();
+          }
+        }
+      };
+      const destroy = () => {
+        if (g) {
+          return;
+        }
+        g = !0;
+        E.destroy();
+        m();
+        w();
+        r.rmSync(a, {
+          force: !0
+        });
+        r.rmSync(f, {
+          force: !0
+        });
+        if (process.env[i.INTERNAL_IPC_ENV] === f) {
+          delete process.env[i.INTERNAL_IPC_ENV];
+        }
+        if (process.env[i.INTERNAL_PROCESS_ORIGIN_ENV] === v) {
+          delete process.env[i.INTERNAL_PROCESS_ORIGIN_ENV];
+        }
+        setLocalProcessOrigin(void 0);
+      };
+      !function registerProcessCleanup(e) {
+        const t = getProcessCleanupState();
+        t.callbacks.add(e);
+        if (t.registered) {
+          return;
+        }
+        t.registered = !0;
+        process.once("exit", runProcessCleanup);
+        for (const e of [ "SIGINT", "SIGTERM", "SIGHUP" ]) {
+          process.once(e, () => {
+            runProcessCleanup();
+            process.kill(process.pid, e);
+          });
+        }
+      }(destroy);
+      return {
+        sessionDir: s,
+        meta: _,
+        sink: E,
+        destroy
+      };
+    }({
+      ...t,
+      onWorkerLine: writeRawLine
+    });
+    setLogPath(S.sessionDir);
+    setEventLoggerInfo({
+      destination: "session",
+      isUserVisibleOutput: !1,
+      sessionDir: S.sessionDir
+    });
+    activateSink(S.sink, t.version);
+    return;
+  }
+};
+
+exports.isEventLoggerActive = () => a.primarySink?.writable ? a.eventLoggerInfo : null;
+//# sourceMappingURL=event-log.js.map