2g 0.0.1-0.wip → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,5 @@
+# 2g
+
+## 0.1.0
+
+Initial Release.

package/LICENSE.md

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) Phil Pluckthun,
+Copyright (c) 650 Industries, Inc. (aka Expo),
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,323 @@
+<div align="center">
+  <h2>2g</h2>
+  <strong>Low-overhead structured event logs for agents and developers</strong>
+  <br />
+  <br />
+</div>
+
+`2g` is a structured event logger for command-line tools. It writes JSONL logs
+that can be replayed, tailed, or exported to trace formats.
+
+In short, `2g`,
+
+- keeps logging cheap enough to leave enabled
+- writes bounded session logs to the system temporary directory
+- forwards worker and child-process events into the same session
+- lets tools and agents tap into running commands
+- derives typed event payloads through TypeScript declaration merging
+
+## Implementation
+
+The goal of `2g` is to replace ad-hoc `debug` logging with structured events
+that are always recorded, without instrumented code paths paying for it. A disabled logging
+call is a single property check, and an enabled call serializes straight into a batched
+file stream — there is no interchange format, no transport negotiation, and no
+per-event allocation beyond the payload the caller already builds.
+
+This has been built with the explicit purpose in mind to:
+
+- Instrument CLI processes that spawn workers and child processes, unifying their events
+  into one session log
+- Keep a bounded, self-cleaning record of recent sessions that tooling and agents can
+  discover and replay after the fact
+- Tap into live processes without those processes knowing or slowing down
+
+As such, sessions write newline-framed JSONL through a single batched fd writer, rotate
+across fixed-size segments, and broadcast to live subscribers over a local socket. Child
+processes and workers inherit the session over an IPC socket published through the
+environment, so the whole process tree agrees on one destination.
+
+The package ships two entrypoints so consumers don't load the producer graph and vice
+versa:
+
+- `2g` — the producer surface instrumented processes import
+- `2g/api` — the consumption surface for tooling that reads sessions
+
+## Quick start
+
+Install logging once when a CLI command starts, then create loggers in any package:
+
+```ts
+import { installEventLogger, events } from '2g';
+
+installEventLogger({ command: 'expo start -p web', version: '1.0.0' });
+
+const log = events('metro');
+
+log('ready', { port: 8081 });
+
+const end = log.span('bundle', { platform: 'ios' });
+end('bundle', { cached: false });
+```
+
+Tap into the session from another terminal:
+
+```sh
+2g tap "expo start" --filter metro:* --tail
+```
+
+## Behavior
+
+### Activation
+
+`installEventLogger` resolves its destination in precedence order:
+
+1. An explicit `LOG_EVENTS` target — an fd number or a file path, from the environment or
+   passed directly
+2. A parent 2g process, inherited through the environment; events forward into the
+   parent's session over IPC
+3. A session in the system temporary directory, when an options object is passed
+4. Otherwise logging stays inactive and all calls are no-ops
+
+Calling `installEventLogger()` with no arguments activates logging only when `LOG_EVENTS`
+or a parent process is present — the right idiom for child processes, workers, and
+libraries. Passing `session: false` keeps this env-only activation while still providing
+options. There is no uninstall: logging is installed once per process and torn down on
+exit.
+
+When `LOG_EVENTS` targets stdout, `console` is transparently redirected to stderr so
+event output stays machine-readable.
+
+### Sessions
+
+Sessions live under `event-log-<uid>` in the system temporary directory. Each
+session directory holds rotating JSONL segments (`0.jsonl` is current), a `meta.json`
+describing the process, and local sockets for live subscribers and child IPC. With the
+defaults of 3 segments × 512 KiB, a session retains roughly the last 12k events.
+
+Stale sessions are cleaned opportunistically: exited sessions are removed after 7 days,
+and only the newest 100 exited sessions are kept. An unwritable temporary directory
+disables session capture without affecting the host process.
+
+### Debug events
+
+`events.debug(category)` creates a logger for chatty, debug-level events. Debug events
+carry `_l: 1` on the wire. Session output drops them at the emit site — keeping the
+rotation budget for normal history — unless `LOG_DEBUG` is set or `installEventLogger`
+is passed `debug: true`; explicit `LOG_EVENTS` targets record them. `tap` and `export`
+skip debug events unless `--debug` (CLI) or `debug: true` (API) is passed.
+
+`LOG_DEBUG` also prints matching events to stderr in a readable format while structured
+logging continues unchanged:
+
+```sh
+LOG_DEBUG=metro:* expo start
+LOG_DEBUG=* expo export
+```
+
+### Deferred payload helpers
+
+`log.path(absolutePath)` logs paths relative to the log target, and `log.error(error)`
+serializes an error to `{ name, message, code, stack, cause }`. Both return
+`Serialized<T>` wrappers — `{ toJSON(): T }` — that only do their work when an event is
+written, so disabled loggers skip `path.relative` calls and `error.stack`
+materialization entirely. Payloads accept `Serialized<T>` wherever their declared types
+expect `T`, so `EventRegistry` declarations keep using the wire shapes.
+
+### Typed events
+
+Extend `EventRegistry` to type event payloads; keys are `category:kind` and payloads
+merge across packages through declaration merging:
+
+```ts
+declare module '2g' {
+  interface EventRegistry {
+    'metro:ready': { port: number };
+    'metro:bundle': { platform?: string; cached?: boolean };
+  }
+}
+```
+
+Unknown event names are uncallable, reserved wire fields (`_e`, `_t`, `_d`, `_l`, `_w`)
+are rejected in payload types, and payloads with no required keys become optional
+arguments. `2g typegen` merges the registry declarations of a whole project into
+one schema.
+
+## CLI
+
+Use the CLI to find sessions, replay logs, or export traces:
+
+```sh
+2g ps --json
+2g tap "expo start" --filter metro:* --tail
+2g export "expo start" --format chrome-trace -o trace.json
+2g export "expo start" --format opentelemetry -o otel.json
+2g typegen --project tsconfig.json --format dts
+2g clean --json
+```
+
+Selectors match a session by PID, command, session directory, or working directory.
+`tap` and `export` replay retained history first. `--tail` appends live events; an event
+written in the instant `--tail` attaches may appear twice at the seam.
+
+Open Chrome traces in [ui.perfetto.dev](https://ui.perfetto.dev) or via Chrome DevTools →
+Performance → "Load profile" (renders as a plain flame chart); `chrome://tracing` is
+deprecated. For a near-live view of a running command, tail the export:
+
+```sh
+2g export "expo start" --tail -o trace.json
+```
+
+## Testing
+
+Capture a subprocess's events in integration tests by handing it a pipe as its
+`LOG_EVENTS` target:
+
+```ts
+import { spawn } from 'node:child_process';
+import { captureEvents } from '2g/api';
+
+const capture = captureEvents({ filter: 'metro:*' });
+const child = spawn(
+  'expo',
+  ['export'],
+  capture.spawnOptions({ env: process.env })
+);
+
+const events = await capture.attach(child).collect();
+```
+
+`spawnOptions` appends a pipe to `stdio` and points `LOG_EVENTS` at it; `attach`
+consumes the pipe and parses events, and can also be iterated with `for await` for live
+consumption. Iteration ends when the pipe closes, so every event the child wrote is
+received.
+
+> [!IMPORTANT]
+> The child's events are flushed on natural exit. Child code that calls `process.exit()`
+> should `await flushEventLogger()` first or trailing events may be lost.
+
+## API Reference
+
+### `2g`
+
+The producer entry that instrumented processes import.
+
+#### `events(category: string) => EventLogger`
+
+Returns a typed logger for `category`. The logger is callable directly and carries
+helpers:
+
+- `log(event, data?)`: writes a `category:event` line with the payload
+- `log.span(event, data?)`: starts a span; returns an `end(event, data?)` function that
+  writes a single event carrying the duration as `_d`
+- `log.path(target)`: returns a `Serialized<string>` of the path relative to the log
+  target
+- `log.error(error)`: returns a `Serialized<SerializedError>` of
+  `{ name, message, code, stack, cause }`, with cause chains serialized recursively
+- `log.category`: the category string
+
+Span kinds ending in `:started`, `:done`, or `:failed` are naming conventions; trace
+exporters strip the suffix from displayed names.
+
+#### `events.debug(category: string) => EventLogger`
+
+Identical to `events(category)`, but events are debug-level (`_l: 1`) and subject to
+debug gating.
+
+#### `installEventLogger(target?: string | number | InstallEventLoggerOptions) => void`
+
+- Accepts an explicit target (fd number or file path) or an options object
+
+Installs logging for the process following the activation precedence above. All options
+are optional:
+
+| Option           | Default | Description                                                                                                       |
+| ---------------- | ------- | ----------------------------------------------------------------------------------------------------------------- |
+| `command`        | argv    | Command line recorded in session metadata                                                                         |
+| `version`        | —       | Tool version recorded in session metadata and the init event                                                      |
+| `maxSegments`    | `3`     | Rotated JSONL segments kept per session                                                                           |
+| `maxSegmentSize` | 512 KiB | Segment size that triggers rotation                                                                               |
+| `session`        | `true`  | Allow the session fall-through; `false` keeps env-only activation                                                 |
+| `debug`          | varies  | Record debug events; defaults to `true` on explicit targets and to `LOG_DEBUG` presence on session and IPC output |
+
+#### `flushEventLogger() => Promise<void>`
+
+Drains buffered events to the active destination. Resolves immediately when logging is
+inactive.
+
+#### `getEventLoggerInfo() => EventLoggerInfo | null`
+
+Returns the active destination — `{ destination, isUserVisibleOutput }` plus a `file`,
+`fd`, or `sessionDir` — or `null` when logging is inactive. `isUserVisibleOutput` is
+`true` when events write to stdout or stderr.
+
+#### `interface Serialized<T>`
+
+```ts
+interface Serialized<T> {
+  toJSON(): T;
+}
+```
+
+A deferred value that serializes to `T` when an event is written. Payload types accept
+`Serialized<T>` wherever `T` is declared, so user code can defer its own expensive
+values the same way.
+
+### `2g/api`
+
+The consumption entry for tooling that reads sessions.
+
+#### `list(options?: ListSessionsOptions) => Promise<ListedSession[]>`
+
+- **Parameters**
+  - `selector?`: matches by PID, command, session directory, or working directory
+
+Returns known sessions, newest first. Each `ListedSession` carries `pid`, `command`,
+`cwd`, `startedAt`, `alive`, and `sessionDir`.
+
+#### `resolveSession(selector?: string) => Promise<ListedSession>`
+
+Resolves a selector to exactly one session, preferring the only alive match. Throws when
+nothing matches or the selector is ambiguous.
+
+#### `tap(sessionDir: string, options?: TapOptions) => AsyncIterable<ParsedEvent>`
+
+Replays a session's retained history and optionally follows live events.
+
+| Option        | Default | Description                                                     |
+| ------------- | ------- | --------------------------------------------------------------- |
+| `since`       | —       | Replay from a duration (`'5m'`), Unix time, ISO date, or `Date` |
+| `follow`      | `false` | Follow live events after replaying history                      |
+| `filter`      | —       | `category[:kind]` patterns; `*` wildcards, comma-separated      |
+| `spans`       | `false` | Only yield events carrying a span duration                      |
+| `debug`       | `false` | Include debug-level events                                      |
+| `signal`      | —       | `AbortSignal` that stops following                              |
+| `timeout`     | —       | Stop following after an absolute duration in milliseconds       |
+| `idleTimeout` | —       | Stop following after this many milliseconds without a new event |
+
+#### `captureEvents(options?: CaptureOptions) => EventCapture`
+
+- **Parameters**
+  - `filter?` and `debug?`: as in `TapOptions`
+
+Returns an `EventCapture` for receiving a subprocess's events over an inherited pipe:
+
+- `capture.spawnOptions(options?)`: returns spawn options with a `'pipe'` slot appended
+  to `stdio` and `LOG_EVENTS` pointing at it, preserving the caller's `env` and `stdio`
+- `capture.attach(child)`: consumes the child's pipe; the capture is an
+  `AsyncIterable<ParsedEvent>` that ends when the pipe closes
+- `capture.collect()`: iterates to the end and returns all events
+
+#### `interface ParsedEvent`
+
+The wire format of a parsed JSONL event; all other properties are payload fields.
+
+```ts
+interface ParsedEvent {
+  _e: string; // "category:kind"
+  _t: number; // wall-clock timestamp in milliseconds
+  _d?: number; // span duration in milliseconds
+  _l?: number; // level; 1 marks debug events
+  _w?: string; // originating worker or child process
+}
+```

package/api/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "2g-api",
+  "private": true,
+  "version": "0.0.0",
+  "main": "../dist/2g-api.js",
+  "module": "../dist/2g-api.mjs",
+  "types": "../dist/2g-api.d.ts",
+  "source": "../src/api.ts",
+  "exports": {
+    ".": {
+      "types": "../dist/2g-api.d.ts",
+      "import": "../dist/2g-api.mjs",
+      "require": "../dist/2g-api.js",
+      "source": "../src/api.ts"
+    }
+  }
+}

package/bin/cli.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+
+(async function main() {
+  let cli;
+  try {
+    cli = await import('../dist/2g-cli.mjs');
+  } catch {
+    cli = require('../dist/2g-cli.js');
+  }
+
+  try {
+    process.exitCode = await cli.main(process.argv.slice(2));
+  } catch (error) {
+    process.stderr.write(
+      `${error instanceof Error ? error.message : String(error)}\n`
+    );
+    process.exitCode = 1;
+  }
+})();

package/cli/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "2g-cli",
+  "private": true,
+  "version": "0.0.0",
+  "main": "../dist/2g-cli.js",
+  "module": "../dist/2g-cli.mjs",
+  "types": "../dist/2g-cli.d.ts",
+  "source": "../src/cli.ts",
+  "exports": {
+    ".": {
+      "types": "../dist/2g-cli.d.ts",
+      "import": "../dist/2g-cli.mjs",
+      "require": "../dist/2g-cli.js",
+      "source": "../src/cli.ts"
+    }
+  }
+}

package/dist/2g-api.d.ts

@@ -0,0 +1,52 @@
+import { S as SessionMeta, P as ParsedEvent } from './chunks/types-chunk.js';
+import { StdioOptions, ChildProcess } from 'node:child_process';
+
+interface EventFilterOptions {
+  since?: number | string | Date;
+  filter?: string | string[];
+  spans?: boolean;
+  debug?: boolean;
+}
+
+interface ListedSession {
+  id: string;
+  pid: number;
+  formatVersion: number;
+  alive: boolean;
+  startedAt: number;
+  command: string;
+  cwd: string;
+  version?: string;
+  origin?: SessionMeta['origin'];
+  sessionDir: string;
+}
+interface ListSessionsOptions {
+  selector?: string;
+}
+interface TapOptions extends EventFilterOptions {
+  follow?: boolean;
+  signal?: AbortSignal;
+  timeout?: number;
+  idleTimeout?: number;
+}
+declare function listSessions(options?: ListSessionsOptions): Promise<ListedSession[]>;
+declare function resolveSession(selector?: string): Promise<ListedSession>;
+declare function tap(sessionDir: string, options?: TapOptions): AsyncIterable<ParsedEvent>;
+
+type CaptureOptions = Pick<TapOptions, 'debug' | 'filter'>;
+interface CaptureSpawnOptions {
+  env?: NodeJS.ProcessEnv;
+  stdio?: StdioOptions;
+}
+declare class EventCapture implements AsyncIterable<ParsedEvent> {
+  #private;
+  constructor(options?: CaptureOptions);
+  spawnOptions<T extends CaptureSpawnOptions>(options?: T): T & Required<CaptureSpawnOptions>;
+  attach(child: ChildProcess): this;
+  collect(): Promise<ParsedEvent[]>;
+  [Symbol.asyncIterator](): AsyncIterator<ParsedEvent>;
+}
+declare function captureEvents(options?: CaptureOptions): EventCapture;
+
+export { EventCapture, ParsedEvent, captureEvents, listSessions as list, resolveSession, tap };
+export type { CaptureOptions, CaptureSpawnOptions, ListSessionsOptions, ListedSession, TapOptions };

package/dist/2g-api.js

@@ -0,0 +1,129 @@
+Object.defineProperty(exports, "__esModule", {
+  value: !0
+});
+
+var t = require("./chunks/tap-chunk.js");
+
+var e = require("./chunks/sessionSockets-chunk.js");
+
+class EventCapture {
+  #t;
+  #e;
+  #s;
+  #i=!1;
+  #n=!1;
+  #r=[];
+  #o=[];
+  constructor(t = {}) {
+    this.#t = t;
+    this.#e = e.compileEventFilter(t.filter);
+  }
+  spawnOptions(t) {
+    const s = Array.isArray(t?.stdio) ? [ ...t.stdio ] : null != t?.stdio ? [ t.stdio, t.stdio, t.stdio ] : [];
+    while (s.length < 3) {
+      s.push("inherit");
+    }
+    this.#s = s.length;
+    s.push("pipe");
+    return {
+      ...t,
+      stdio: s,
+      env: {
+        ...t?.env ?? process.env,
+        [e.LOG_EVENTS_ENV]: `${this.#s}`
+      }
+    };
+  }
+  attach(t) {
+    if (null == this.#s) {
+      throw new Error("captureEvents: spawnOptions() must create the pipe before attach()");
+    }
+    if (this.#i) {
+      throw new Error("captureEvents: a child is already attached");
+    }
+    const e = t.stdio[this.#s];
+    if (!e || "function" != typeof e.setEncoding) {
+      throw new Error(`captureEvents: child stdio[${this.#s}] is not a readable pipe`);
+    }
+    this.#i = !0;
+    let s = "";
+    e.setEncoding("utf8");
+    e.on("data", t => {
+      const e = s ? s + t : t;
+      let i = 0;
+      let n;
+      while (-1 !== (n = e.indexOf("\n", i))) {
+        const t = e.slice(i, n);
+        i = n + 1;
+        if (t) {
+          this.#h(t);
+        }
+      }
+      s = i ? e.slice(i) : e;
+    });
+    const finish = () => {
+      if (this.#n) {
+        return;
+      }
+      this.#n = !0;
+      if (s) {
+        this.#h(s);
+      }
+      this.#a(null);
+    };
+    e.on("end", finish);
+    e.on("close", finish);
+    e.on("error", finish);
+    return this;
+  }
+  async collect() {
+    const t = [];
+    for await (const e of this) {
+      t.push(e);
+    }
+    return t;
+  }
+  async* [Symbol.asyncIterator]() {
+    let t;
+    while (t = await this.#c()) {
+      yield t;
+    }
+  }
+  #h(t) {
+    const s = e.parseEventLine(t, this.#t, this.#e);
+    if (s) {
+      this.#a(s);
+    }
+  }
+  #a(t) {
+    const e = this.#o.shift();
+    if (e) {
+      e(t);
+    } else if (t) {
+      this.#r.push(t);
+    }
+  }
+  #c() {
+    if (this.#r.length) {
+      return Promise.resolve(this.#r.shift());
+    }
+    if (this.#n) {
+      return Promise.resolve(null);
+    }
+    if (!this.#i) {
+      throw new Error("captureEvents: attach() a child before iterating");
+    }
+    return new Promise(t => this.#o.push(t));
+  }
+}
+
+exports.list = t.listSessions;
+
+exports.resolveSession = t.resolveSession;
+
+exports.tap = t.tap;
+
+exports.captureEvents = function captureEvents(t) {
+  return new EventCapture(t);
+};
+//# sourceMappingURL=2g-api.js.map

package/dist/2g-api.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"2g-api.js","sources":["../src/capture.ts"],"sourcesContent":["import type { ChildProcess, StdioOptions } from 'node:child_process';\nimport type { Readable } from 'node:stream';\n\nimport { LOG_EVENTS_ENV } from './constants';\nimport type { TapOptions } from './tap';\nimport type { ParsedEvent } from './types';\nimport { compileEventFilter, parseEventLine } from './utils/eventFilter';\n\nexport type CaptureOptions = Pick<TapOptions, 'debug' | 'filter'>;\n\nexport interface CaptureSpawnOptions {\n  env?: NodeJS.ProcessEnv;\n  stdio?: StdioOptions;\n}\n\nexport class EventCapture implements AsyncIterable<ParsedEvent> {\n  #options: CaptureOptions;\n  #eventFilter: RegExp | null;\n  #index: number | undefined;\n  #attached = false;\n  #done = false;\n  #events: ParsedEvent[] = [];\n  #waiters: Array<(event: ParsedEvent | null) => void> = [];\n\n  constructor(options: CaptureOptions = {}) {\n    this.#options = options;\n    this.#eventFilter = compileEventFilter(options.filter);\n  }\n\n  spawnOptions<T extends CaptureSpawnOptions>(\n    options?: T\n  ): T & Required<CaptureSpawnOptions> {\n    const stdio: Extract<StdioOptions, readonly unknown[]> = Array.isArray(\n      options?.stdio\n    )\n      ? [...options.stdio]\n      : options?.stdio != null\n        ? [options.stdio, options.stdio, options.stdio]\n        : [];\n    while (stdio.length < 3) stdio.push('inherit');\n    this.#index = stdio.length;\n    stdio.push('pipe');\n    return {\n      ...(options as T),\n      stdio,\n      env: {\n        ...(options?.env ?? process.env),\n        [LOG_EVENTS_ENV]: `${this.#index}`,\n      },\n    };\n  }\n\n  attach(child: ChildProcess): this {\n    if (this.#index == null)\n      throw new Error(\n        'captureEvents: spawnOptions() must create the pipe before attach()'\n      );\n    if (this.#attached)\n      throw new Error('captureEvents: a child is already attached');\n    const stream = child.stdio[this.#index] as Readable | null | undefined;\n    if (!stream || typeof stream.setEncoding !== 'function')\n      throw new Error(\n        `captureEvents: child stdio[${this.#index}] is not a readable pipe`\n      );\n    this.#attached = true;\n\n    let pending = '';\n    stream.setEncoding('utf8');\n    stream.on('data', (chunk: string) => {\n      const data = pending ? pending + chunk : chunk;\n      let start = 0;\n      let end: number;\n      while ((end = data.indexOf('\\n', start)) !== -1) {\n        const line = data.slice(start, end);\n        start = end + 1;\n        if (line) this.#ingest(line);\n      }\n      pending = start ? data.slice(start) : data;\n    });\n\n    const finish = () => {\n      if (this.#done) return;\n      this.#done = true;\n      if (pending) this.#ingest(pending);\n      this.#notify(null);\n    };\n    stream.on('end', finish);\n    stream.on('close', finish);\n    stream.on('error', finish);\n    return this;\n  }\n\n  async collect(): Promise<ParsedEvent[]> {\n    const events: ParsedEvent[] = [];\n    for await (const event of this) events.push(event);\n    return events;\n  }\n\n  async *[Symbol.asyncIterator](): AsyncIterator<ParsedEvent> {\n    let event: ParsedEvent | null;\n    while ((event = await this.#next())) yield event;\n  }\n\n  #ingest(line: string) {\n    const event = parseEventLine(line, this.#options, this.#eventFilter);\n    if (event) this.#notify(event);\n  }\n\n  #notify(event: ParsedEvent | null) {\n    const waiter = this.#waiters.shift();\n    if (waiter) waiter(event);\n    else if (event) this.#events.push(event);\n  }\n\n  #next(): Promise<ParsedEvent | null> {\n    if (this.#events.length) return Promise.resolve(this.#events.shift()!);\n    if (this.#done) return Promise.resolve(null);\n    if (!this.#attached)\n      throw new Error('captureEvents: attach() a child before iterating');\n    return new Promise(resolve => this.#waiters.push(resolve));\n  }\n}\n\nexport function captureEvents(options?: CaptureOptions): EventCapture {\n  return new EventCapture(options);\n}\n"],"names":["EventCapture","options","eventFilter","index","attached","done","events","waiters","constructor","this","compileEventFilter","filter","spawnOptions","stdio","Array","isArray","length","push","env","process","LOG_EVENTS_ENV","attach","child","Error","stream","setEncoding","pending","on","chunk","data","start","end","indexOf","line","slice","ingest","finish","notify","collect","event","Symbol","asyncIterator","next","parseEventLine","waiter","shift","Promise","resolve","captureEvents"],"mappings":";;;;;;;;AAeO,MAAMA;EACXC;EACAC;EACAC;EACAC,IAAY;EACZC,IAAQ;EACRC,GAAyB;EACzBC,GAAuD;EAEvDC,WAAAA,CAAYP,IAA0B;IACpCQ,MAAKR,IAAWA;IAChBQ,MAAKP,IAAeQ,qBAAmBT,EAAQU;AACjD;EAEAC,YAAAA,CACEX;IAEA,MAAMY,IAAmDC,MAAMC,QAC7Dd,GAASY,SAEP,KAAIZ,EAAQY,UACM,QAAlBZ,GAASY,QACP,EAACZ,EAAQY,OAAOZ,EAAQY,OAAOZ,EAAQY,UACvC;IACN,OAAOA,EAAMG,SAAS;MAAGH,EAAMI,KAAK;;IACpCR,MAAKN,IAASU,EAAMG;IACpBH,EAAMI,KAAK;IACX,OAAO;SACDhB;MACJY;MACAK,KAAK;WACCjB,GAASiB,OAAOC,QAAQD;QAC5B,CAACE,mBAAiB,GAAGX,MAAKN;;;AAGhC;EAEAkB,MAAAA,CAAOC;IACL,IAAmB,QAAfb,MAAKN;MACP,MAAM,IAAIoB,MACR;;IAEJ,IAAId,MAAKL;MACP,MAAM,IAAImB,MAAM;;IAClB,MAAMC,IAASF,EAAMT,MAAMJ,MAAKN;IAChC,KAAKqB,KAAwC,qBAAvBA,EAAOC;MAC3B,MAAM,IAAIF,MACR,8BAA8Bd,MAAKN;;IAEvCM,MAAKL,KAAY;IAEjB,IAAIsB,IAAU;IACdF,EAAOC,YAAY;IACnBD,EAAOG,GAAG,QAASC;MACjB,MAAMC,IAAOH,IAAUA,IAAUE,IAAQA;MACzC,IAAIE,IAAQ;MACZ,IAAIC;MACJ,eAAQA,IAAMF,EAAKG,QAAQ,MAAMF,KAAgB;QAC/C,MAAMG,IAAOJ,EAAKK,MAAMJ,GAAOC;QAC/BD,IAAQC,IAAM;QACd,IAAIE;UAAMxB,MAAK0B,EAAQF;;AACzB;MACAP,IAAUI,IAAQD,EAAKK,MAAMJ,KAASD;;IAGxC,MAAMO,SAASA;MACb,IAAI3B,MAAKJ;QAAO;;MAChBI,MAAKJ,KAAQ;MACb,IAAIqB;QAASjB,MAAK0B,EAAQT;;MAC1BjB,MAAK4B,EAAQ;;IAEfb,EAAOG,GAAG,OAAOS;IACjBZ,EAAOG,GAAG,SAASS;IACnBZ,EAAOG,GAAG,SAASS;IACnB,OAAO3B;AACT;EAEA,aAAM6B;IACJ,MAAMhC,IAAwB;IAC9B,WAAW,MAAMiC,KAAS9B;MAAMH,EAAOW,KAAKsB;;IAC5C,OAAOjC;AACT;EAEA,QAAQkC,OAAOC;IACb,IAAIF;IACJ,OAAQA,UAAc9B,MAAKiC;YAAgBH;;AAC7C;EAEA,EAAAJ,CAAQF;IACN,MAAMM,IAAQI,EAAAA,eAAeV,GAAMxB,MAAKR,GAAUQ,MAAKP;IACvD,IAAIqC;MAAO9B,MAAK4B,EAAQE;;AAC1B;EAEA,EAAAF,CAAQE;IACN,MAAMK,IAASnC,MAAKF,EAASsC;IAC7B,IAAID;MAAQA,EAAOL;WACd,IAAIA;MAAO9B,MAAKH,EAAQW,KAAKsB;;AACpC;EAEA,EAAAG;IACE,IAAIjC,MAAKH,EAAQU;MAAQ,OAAO8B,QAAQC,QAAQtC,MAAKH,EAAQuC;;IAC7D,IAAIpC,MAAKJ;MAAO,OAAOyC,QAAQC,QAAQ;;IACvC,KAAKtC,MAAKL;MACR,MAAM,IAAImB,MAAM;;IAClB,OAAO,IAAIuB,QAAQC,KAAWtC,MAAKF,EAASU,KAAK8B;AACnD;;;;;;;;;wBAGK,SAASC,cAAc/C;EAC5B,OAAO,IAAID,aAAaC;AAC1B"}