react-native-nitro-logger 0.1.0

package/lib/module/destinations/ConsoleDestination.js

@@ -0,0 +1,51 @@
+"use strict";
+
+import { DefaultFormatter } from "../formatters/DefaultFormatter.js";
+import { LEVEL_ORDER } from "../levels.js";
+
+/**
+ * Renders to the JS console (Metro in dev). warning → console.warn and
+ * error/todo → console.error deliberately: LogBox surfacing errors in dev is
+ * a feature, not noise.
+ *
+ * `outputSink` mirrors SwiftLogger's test hook: when set, lines are also
+ * handed to the sink, and `isEnabled` stays true even with printing off.
+ */
+export class ConsoleDestination {
+  label = 'console';
+  printEnabled = true;
+  constructor(options) {
+    this.minimumLevel = options?.minimumLevel;
+    this.formatter = options?.formatter ?? new DefaultFormatter();
+  }
+  get isEnabled() {
+    return this.printEnabled || this.outputSink !== undefined;
+  }
+  write(entry) {
+    const line = this.formatter.format(entry);
+    if (this.outputSink) {
+      // Guarded: a faulty observer must not suppress console output or get
+      // the whole destination disabled as repeatedly failing.
+      try {
+        this.outputSink(line);
+      } catch {
+        // observer-only failure; console printing below still runs
+      }
+    }
+    if (!this.printEnabled) return;
+    if (LEVEL_ORDER[entry.level] >= LEVEL_ORDER.error) {
+      console.error(line);
+    } else if (entry.level === 'warning') {
+      console.warn(line);
+    } else {
+      console.log(line);
+    }
+  }
+  flush() {
+    // console writes are synchronous; nothing buffers here
+  }
+  dispose() {
+    this.outputSink = undefined;
+  }
+}
+//# sourceMappingURL=ConsoleDestination.js.map

package/lib/module/destinations/ConsoleDestination.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["DefaultFormatter","LEVEL_ORDER","ConsoleDestination","label","printEnabled","constructor","options","minimumLevel","formatter","isEnabled","outputSink","undefined","write","entry","line","format","level","error","console","warn","log","flush","dispose"],"sourceRoot":"../../../src","sources":["destinations/ConsoleDestination.ts"],"mappings":";;AAGA,SAASA,gBAAgB,QAAQ,mCAAgC;AACjE,SAASC,WAAW,QAAQ,cAAW;;AAEvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,kBAAkB,CAA2B;EAC/CC,KAAK,GAAG,SAAS;EAE1BC,YAAY,GAAG,IAAI;EAKnBC,WAAWA,CAACC,OAA+D,EAAE;IAC3E,IAAI,CAACC,YAAY,GAAGD,OAAO,EAAEC,YAAY;IACzC,IAAI,CAACC,SAAS,GAAGF,OAAO,EAAEE,SAAS,IAAI,IAAIR,gBAAgB,CAAC,CAAC;EAC/D;EAEA,IAAIS,SAASA,CAAA,EAAY;IACvB,OAAO,IAAI,CAACL,YAAY,IAAI,IAAI,CAACM,UAAU,KAAKC,SAAS;EAC3D;EAEAC,KAAKA,CAACC,KAAe,EAAQ;IAC3B,MAAMC,IAAI,GAAG,IAAI,CAACN,SAAS,CAACO,MAAM,CAACF,KAAK,CAAC;IACzC,IAAI,IAAI,CAACH,UAAU,EAAE;MACnB;MACA;MACA,IAAI;QACF,IAAI,CAACA,UAAU,CAACI,IAAI,CAAC;MACvB,CAAC,CAAC,MAAM;QACN;MAAA;IAEJ;IACA,IAAI,CAAC,IAAI,CAACV,YAAY,EAAE;IACxB,IAAIH,WAAW,CAACY,KAAK,CAACG,KAAK,CAAC,IAAIf,WAAW,CAACgB,KAAK,EAAE;MACjDC,OAAO,CAACD,KAAK,CAACH,IAAI,CAAC;IACrB,CAAC,MAAM,IAAID,KAAK,CAACG,KAAK,KAAK,SAAS,EAAE;MACpCE,OAAO,CAACC,IAAI,CAACL,IAAI,CAAC;IACpB,CAAC,MAAM;MACLI,OAAO,CAACE,GAAG,CAACN,IAAI,CAAC;IACnB;EACF;EAEAO,KAAKA,CAAA,EAAS;IACZ;EAAA;EAGFC,OAAOA,CAAA,EAAS;IACd,IAAI,CAACZ,UAAU,GAAGC,SAAS;EAC7B;AACF","ignoreList":[]}

package/lib/module/destinations/FileDestination.js

@@ -0,0 +1,360 @@
+"use strict";
+
+import { Batcher } from "./Batcher.js";
+import { JsonLinesFormatter } from "../formatters/JsonLinesFormatter.js";
+import { utf8Length } from "../utf8.js";
+
+/**
+ * The part of `FileSink` a `FileDestination` uses.
+ *
+ * Structural rather than the Nitro interface itself, so the destination can
+ * be driven by a scripted double in tests. The real `FileSink` satisfies it.
+ */
+
+const DEFAULT_LABEL = 'file';
+const DEFAULT_FILENAME = 'app.log';
+const DEFAULT_MAX_ENTRY_BYTES = 64 * 1024;
+const DEFAULT_DEADLINE_MS = 2000;
+
+/** Fixed text: a diagnostic that interpolates caller data is a log-injection
+ * hole and a privacy hole at once. Only counts travel with it. */
+const LOSS_MESSAGE = 'log entries were dropped';
+const OVERSIZE_MESSAGE = 'a log entry was too large to record';
+
+/**
+ * Writes formatted records to a native file sink, batched and backpressured.
+ *
+ * The division of labour is the whole design: this side decides what to write
+ * and what to give up on, the sink only appends text and reports counters.
+ * Everything interesting — batching, drop policy, loss notices, the purge
+ * handshake — is therefore testable without a device.
+ *
+ * Three behaviours are worth knowing about before using it.
+ *
+ * **Oversized entries are never sliced.** A formatter that can shed structure
+ * is asked to re-render within the limit; one that cannot has its output
+ * replaced whole by a fixed notice. Cutting a rendered record to length is
+ * how a log file stops being parseable, and an unparseable file is worth less
+ * than an honestly incomplete one.
+ *
+ * **Framing is declared, not assumed.** A formatter guaranteeing one record
+ * per line lets the native side trim a torn trailing record after a crash.
+ * Without that guarantee the file is left as the crash left it, because a
+ * writer cannot tell a torn record from an intentional newline.
+ *
+ * **A fenced handle stays fenced.** When the sink reports that this handle's
+ * generation is stale — someone purged the file underneath it — the buffer is
+ * discarded rather than replayed into the new file, and the destination
+ * disables itself. Pre-purge records must not reappear after a compliance
+ * deletion. The handle that invoked the purge rebinds; any other one does
+ * not, and reacquisition is the native registry's job.
+ */
+export class FileDestination {
+  /** Held for the M5 registry's reacquisition path, which needs the same
+   * config the handle was opened with. */
+
+  fenced = false;
+  disposed = false;
+  constructor(sink, options = {}) {
+    this.sink = sink;
+    this.label = options.label ?? DEFAULT_LABEL;
+    this.minimumLevel = options.minimumLevel;
+    this.formatter = options.formatter ?? new JsonLinesFormatter();
+    this.maxEntryBytes = positive(options.maxEntryBytes, DEFAULT_MAX_ENTRY_BYTES);
+    this.path = options.path ?? `${sink.defaultLogDirectory}/${DEFAULT_FILENAME}`;
+    this.rotation = options.rotation;
+    this.batcher = new Batcher(sink, {
+      renderNotice: lost => this.renderLossNotice(lost),
+      onFenced: reason => this.onFenced(reason),
+      batchBytes: options.batchBytes,
+      flushIntervalMs: options.flushIntervalMs,
+      maxPendingEntries: options.maxPendingEntries,
+      maxPendingBytes: options.maxPendingBytes,
+      watermarkBytes: options.watermarkBytes
+    });
+
+    // Throws on open failure or on a config conflict with an existing writer,
+    // and deliberately so: a file destination that silently writes nowhere is
+    // worse than one that refuses to be constructed.
+    sink.open(this.path, this.rotation, this.lineFramed);
+  }
+
+  /** True only while this handle may write. */
+  get isEnabled() {
+    return !this.fenced && !this.disposed;
+  }
+
+  /** Where records are going. */
+  get filePath() {
+    return this.path;
+  }
+
+  /**
+   * Whether the native side may trim a torn trailing record after a crash.
+   * Follows the formatter's declaration; nothing infers it.
+   */
+  get lineFramed() {
+    return this.formatter.framing === 'line';
+  }
+  write(entry) {
+    if (!this.isEnabled) return;
+    const record = this.renderRecord(entry);
+    if (record === undefined) return;
+    this.batcher.add(record);
+  }
+
+  /**
+   * Drain to disk and fsync, bounded by a wall-clock deadline.
+   *
+   * Returns the outcome even though `LogDestination` asks only for `void`: a
+   * caller flushing before backgrounding or on a crash path needs to know
+   * whether it worked, and `durable: false` is the answer that matters.
+   */
+  flush(deadlineMs = DEFAULT_DEADLINE_MS) {
+    return this.batcher.flush(deadlineMs);
+  }
+
+  /** Current file and archives, newest first; empty if the sink refuses. */
+  getLogFilePaths() {
+    try {
+      return this.sink.getLogFilePaths();
+    } catch {
+      return [];
+    }
+  }
+
+  /** Losses with no notice in the file yet. */
+  unreportedLoss() {
+    return this.batcher.unreported();
+  }
+
+  /**
+   * What has stopped working underneath, as a payload-free bitmask —
+   * rotation, gzip, prune, sidecar, protection.
+   *
+   * The mask exists because the alternative is a message, and a message built
+   * from an `errno` string or a path is exactly the kind of thing that carries
+   * a username into a log file. Bits carry no payload, so an app can surface
+   * "log rotation is failing" to support without surfacing anything else.
+   *
+   * Non-zero does not mean records are being lost — a failed compression or a
+   * failed prune costs disk, not data. Check {@link unreportedLoss} for that.
+   */
+  degradation() {
+    return this.batcher.degradation();
+  }
+
+  /**
+   * Delete every log artifact, then rebind.
+   *
+   * The ordering is the point. This handle is fenced first, so nothing can be
+   * written into the window where deletion is in flight; the JS buffer is
+   * discarded rather than flushed, because flushing it would write pre-purge
+   * records into the file a moment before deleting it — or worse, a moment
+   * after. Only a durable deletion lifts the fence. A partial or timed-out
+   * one leaves this handle disabled until an explicit retry, so a late
+   * deletion can never race a fresh write.
+   *
+   * Discarded counts come back here rather than going into a loss notice: a
+   * "4,182 entries dropped" line at the top of a file that was just cleared
+   * for compliance describes the clearing, which the caller already knows
+   * about.
+   */
+  purge(deadlineMs = DEFAULT_DEADLINE_MS) {
+    // A disposed destination has closed its sink, and a closed sink has no
+    // handle left to delete through — so this call cannot do the one thing it
+    // exists to do. Saying so is the entire point: the alternative is a
+    // `durable: true` over files that are still on disk, told to the one caller
+    // who asked because they are legally obliged to know. `removeDestination()`
+    // then a compliance purge is an ordinary sequence, not a contrived one.
+    if (this.disposed) {
+      return {
+        durable: false,
+        rebound: false,
+        deletedCount: 0,
+        failedPaths: [],
+        discardedEntries: 0,
+        discardedBytes: 0
+      };
+    }
+    this.fenced = true;
+    const discarded = this.batcher.discard();
+    let outcome;
+    try {
+      outcome = this.sink.clearLogs(deadlineMs);
+    } catch {
+      return {
+        durable: false,
+        // The call threw, so nothing is known about the sink's state and the
+        // fence set above stays up. Reporting a rebind here would lift it.
+        rebound: false,
+        deletedCount: 0,
+        failedPaths: [],
+        discardedEntries: discarded.entries,
+        discardedBytes: discarded.bytes
+      };
+    }
+
+    // Both facts, not just the first. `durable` says the artifacts are gone;
+    // `rebound` says the sink has a usable file again. Lifting the fence on
+    // `durable` alone resumes writing into a handle the sink never rebound —
+    // every record accepted, rejected as `staleGeneration`, and dropped. The
+    // deletion is still complete and still reported as such; the destination
+    // just stays disabled until an explicit retry gets a live file back.
+    //
+    // `=== true`, not `!== false`. An absent field is not a promise, and the
+    // sink most likely to omit it is one that predates it — including a native
+    // build that deletes by closing and never reopens at all. A JS bundle can
+    // be updated over the air without the binary underneath it changing, so
+    // "old native, new JS" is a real pairing, and reading silence as success
+    // there rebuilds exactly the silent post-purge loss this flag exists to
+    // stop. Staying fenced until a retry is the failure that announces itself.
+    const resumed = outcome.durable && outcome.rebound === true;
+    if (resumed) {
+      this.fenced = this.disposed;
+      this.batcher.rebind();
+    }
+    return {
+      durable: outcome.durable,
+      rebound: resumed,
+      deletedCount: count(outcome.deletedCount),
+      failedPaths: Array.isArray(outcome.failedPaths) ? outcome.failedPaths : [],
+      discardedEntries: discarded.entries,
+      discardedBytes: discarded.bytes
+    };
+  }
+
+  /** Idempotent: flush what is buffered, release the timer, close the sink. */
+  dispose() {
+    if (this.disposed) return;
+    try {
+      this.batcher.flush(DEFAULT_DEADLINE_MS);
+    } catch {
+      // a failing drain must not leak the handle below
+    }
+    this.disposed = true;
+    this.batcher.dispose();
+    try {
+      this.sink.close(DEFAULT_DEADLINE_MS);
+    } catch {
+      // nothing left to salvage
+    }
+  }
+
+  // ── Internals ───────────────────────────────────────────────────────────
+
+  /**
+   * Render one entry, or account for why it could not be rendered.
+   *
+   * Returns undefined when nothing writable came out; the loss is recorded
+   * before returning, so an entry is either in the file or in the counters
+   * and never in neither.
+   */
+  renderRecord(entry) {
+    const record = this.formatOrUndefined(entry);
+    if (record === undefined) {
+      this.batcher.noteLoss(1, 0);
+      return undefined;
+    }
+
+    // The ORIGINAL size, held onto for the rest of this method. What gets
+    // discarded is the entry the caller wrote, so that is the number the
+    // counters and the notice have to carry — not the size of whatever
+    // undersized floor the formatter came back with instead.
+    const bytes = utf8Length(record);
+    if (bytes <= this.maxEntryBytes) return record;
+
+    // Structural shedding first: a formatter that knows its own shape can
+    // drop whole fields and truncate one at code-point boundaries, and what
+    // comes back is still valid in that format.
+    if (this.formatter.formatWithin) {
+      const shorter = this.formatWithinOrUndefined(entry);
+      if (shorter !== undefined && utf8Length(shorter) <= this.maxEntryBytes) {
+        return shorter;
+      }
+      // Still over: a record has a floor below which it identifies nothing.
+    }
+
+    // Nothing renderable fits, so the entry is replaced whole by a notice in
+    // the same format. Never sliced: a fragment of a record is not a record.
+    this.batcher.noteLoss(1, bytes);
+    return this.boundedNotice(noticeEntry(entry.timestamp, OVERSIZE_MESSAGE, {
+      droppedBytes: bytes
+    }));
+  }
+  renderLossNotice(lost) {
+    return this.boundedNotice(noticeEntry(Date.now(), LOSS_MESSAGE, {
+      droppedEntries: lost.entries,
+      droppedBytes: lost.bytes
+    }));
+  }
+
+  /**
+   * Render one of the pipeline's own notices under the same per-entry limit
+   * as everything else.
+   *
+   * The limit exists so a batch always fits the sink. A notice exempt from it
+   * could be refused forever by a sink that will never take it, and the loss
+   * it describes would sit undelivered behind it — the pipeline's own
+   * diagnostics jamming the pipeline. Returning undefined when nothing fits
+   * leaves the loss counted and owed, which is the honest outcome.
+   */
+  boundedNotice(entry) {
+    const text = this.formatOrUndefined(entry);
+    if (text === undefined) return undefined;
+    if (utf8Length(text) <= this.maxEntryBytes) return text;
+    if (this.formatter.formatWithin) {
+      const shorter = this.formatWithinOrUndefined(entry);
+      if (shorter !== undefined && utf8Length(shorter) <= this.maxEntryBytes) {
+        return shorter;
+      }
+    }
+    return undefined;
+  }
+  formatOrUndefined(entry) {
+    try {
+      const text = this.formatter.format(entry);
+      return typeof text === 'string' ? text : undefined;
+    } catch {
+      return undefined;
+    }
+  }
+  formatWithinOrUndefined(entry) {
+    try {
+      const text = this.formatter.formatWithin(entry, this.maxEntryBytes);
+      return typeof text === 'string' ? text : undefined;
+    } catch {
+      return undefined;
+    }
+  }
+  onFenced(_reason) {
+    this.fenced = true;
+  }
+}
+
+/**
+ * A synthetic entry describing the pipeline's own state.
+ *
+ * Built directly rather than routed through the logger: it carries only
+ * counts, so there is nothing for redaction to protect, and going through the
+ * logger would put it behind the very destination that is trying to report a
+ * problem.
+ */
+function noticeEntry(timestamp, message, metadata) {
+  return Object.freeze({
+    timestamp,
+    level: 'warning',
+    message,
+    metadata: Object.freeze({
+      ...metadata
+    }),
+    subsystem: 'logger'
+  });
+}
+function positive(value, fallback) {
+  return typeof value === 'number' && Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+}
+function count(value) {
+  return typeof value === 'number' && Number.isFinite(value) && value > 0 ? Math.floor(value) : 0;
+}
+//# sourceMappingURL=FileDestination.js.map

package/lib/module/destinations/FileDestination.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Batcher","JsonLinesFormatter","utf8Length","DEFAULT_LABEL","DEFAULT_FILENAME","DEFAULT_MAX_ENTRY_BYTES","DEFAULT_DEADLINE_MS","LOSS_MESSAGE","OVERSIZE_MESSAGE","FileDestination","fenced","disposed","constructor","sink","options","label","minimumLevel","formatter","maxEntryBytes","positive","path","defaultLogDirectory","rotation","batcher","renderNotice","lost","renderLossNotice","onFenced","reason","batchBytes","flushIntervalMs","maxPendingEntries","maxPendingBytes","watermarkBytes","open","lineFramed","isEnabled","filePath","framing","write","entry","record","renderRecord","undefined","add","flush","deadlineMs","getLogFilePaths","unreportedLoss","unreported","degradation","purge","durable","rebound","deletedCount","failedPaths","discardedEntries","discardedBytes","discarded","discard","outcome","clearLogs","entries","bytes","resumed","rebind","count","Array","isArray","dispose","close","formatOrUndefined","noteLoss","formatWithin","shorter","formatWithinOrUndefined","boundedNotice","noticeEntry","timestamp","droppedBytes","Date","now","droppedEntries","text","format","_reason","message","metadata","Object","freeze","level","subsystem","value","fallback","Number","isFinite","Math","floor"],"sourceRoot":"../../../src","sources":["destinations/FileDestination.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/destinations/NativeConsoleDestination.js

@@ -0,0 +1,170 @@
+"use strict";
+
+import { DefaultFormatter } from "../formatters/DefaultFormatter.js";
+import { LEVEL_ORDER } from "../levels.js";
+
+/**
+ * The part of `NativeConsoleSink` this destination uses.
+ *
+ * Structural rather than the Nitro interface itself, so tests can drive it
+ * with a double. The real `NativeConsoleSink` satisfies it.
+ */
+
+const DEFAULT_BATCH_SIZE = 64;
+const DEFAULT_FLUSH_INTERVAL_MS = 100;
+const DEFAULT_MAX_PENDING = 1000;
+
+/**
+ * Number of consecutive failed `logBatch` calls before the destination stops
+ * trying. A native sink that is throwing every time will not start working
+ * because we asked once more, and a try/catch per drain forever is a cost the
+ * app pays for nothing.
+ */
+const FAILURE_LIMIT = 3;
+
+/**
+ * Renders entries into the platform log stream — os_log on iOS, logcat on
+ * Android — so JS logs interleave with native ones in Console.app and Xcode.
+ *
+ * Batched, unlike {@link ConsoleDestination}: one bridge crossing per drain
+ * with two parallel primitive arrays, rather than a crossing per entry.
+ *
+ * Deliberately simpler than {@link FileDestination}. There is no backpressure
+ * and no loss accounting because there is nothing to push back on: os_log
+ * accepts what it is given and never blocks on a disk. What this destination
+ * does account for is its own buffer — entries dropped at the ceiling, and
+ * entries lost to a throwing sink — through {@link dropped}, because a
+ * diagnostic channel that quietly loses records is worse than one that says
+ * it did.
+ *
+ * The durable copy is the file destination's. Nothing here is a system of
+ * record, which is what makes best-effort the right posture.
+ */
+export class NativeConsoleDestination {
+  levels = [];
+  messages = [];
+  disposed = false;
+  failures = 0;
+  droppedEntries = 0;
+  constructor(sink, options) {
+    this.sink = sink;
+    this.label = options?.label ?? 'native-console';
+    this.minimumLevel = options?.minimumLevel;
+    this.formatter = options?.formatter ?? new DefaultFormatter();
+    this.batchSize = positive(options?.batchSize, DEFAULT_BATCH_SIZE);
+    this.flushIntervalMs = positive(options?.flushIntervalMs, DEFAULT_FLUSH_INTERVAL_MS);
+    this.maxPending = positive(options?.maxPendingEntries, DEFAULT_MAX_PENDING);
+
+    // An empty subsystem is legal and produces a logger nobody can find in
+    // Console; the native side substitutes the bundle identifier for it.
+    this.sink.install(options?.subsystem ?? '', options?.category ?? 'log');
+  }
+
+  /**
+   * False once disposed, or once the native sink has failed enough times in a
+   * row to be considered gone. The Logger checks this before formatting, so a
+   * dead sink stops costing render work as well as bridge calls.
+   */
+  get isEnabled() {
+    return !this.disposed && this.failures < FAILURE_LIMIT;
+  }
+
+  /** Entries this destination never handed to the platform log. */
+  dropped() {
+    return this.droppedEntries;
+  }
+  write(entry) {
+    if (!this.isEnabled) return;
+    if (this.messages.length >= this.maxPending) {
+      // Drop-newest, matching the Batcher. Under a burst the oldest entries
+      // are the ones that explain how it started, which is what a reader is
+      // looking for; keeping the newest would leave only the aftermath.
+      this.droppedEntries += 1;
+      return;
+    }
+
+    // Render first, then append both halves together. The two arrays are
+    // parallel and are read by index natively, so pushing the level before the
+    // message that might not arrive leaves them one apart — and from that point
+    // on every entry in the batch is logged at its predecessor's severity. The
+    // Logger catches a throwing destination and carries on, which is exactly
+    // what would let the misalignment survive unnoticed.
+    let rendered;
+    try {
+      rendered = this.formatter.format(entry);
+    } catch {
+      // Not counted against the sink's failure run: the sink is fine, the
+      // formatter is not, and disabling the channel over someone else's bug
+      // would take the console down for every entry a working formatter could
+      // still have rendered.
+      this.droppedEntries += 1;
+      return;
+    }
+    this.levels.push(LEVEL_ORDER[entry.level]);
+    this.messages.push(rendered);
+    if (this.messages.length >= this.batchSize) {
+      this.drain();
+      return;
+    }
+    this.arm();
+  }
+
+  /**
+   * Hands everything buffered to the platform log.
+   *
+   * The deadline is accepted and ignored, deliberately: `logBatch` does not
+   * wait on anything, so there is no wait to bound. Taking the parameter keeps
+   * the destination interchangeable with the ones that do need it.
+   */
+  flush(_deadlineMs) {
+    this.drain();
+  }
+  dispose() {
+    if (this.disposed) return;
+    // Flush before the flag, not after: entries buffered up to this moment
+    // were accepted, and disposing is not a reason to drop them.
+    this.drain();
+    this.disposed = true;
+    this.cancel();
+  }
+  drain() {
+    this.cancel();
+    if (this.messages.length === 0) return;
+    const levels = this.levels;
+    const messages = this.messages;
+    this.levels = [];
+    this.messages = [];
+    if (this.disposed) return;
+    try {
+      this.sink.logBatch(levels, messages);
+      this.failures = 0;
+    } catch {
+      // Payload-free: whatever the native side threw is not worth risking on
+      // the way back through a logger. The batch is gone either way, so it is
+      // counted rather than retried — replaying it against a sink that just
+      // rejected it only doubles the chance of the same failure.
+      this.failures += 1;
+      this.droppedEntries += messages.length;
+    }
+  }
+  arm() {
+    if (this.timer !== undefined) return;
+    this.timer = setTimeout(() => {
+      this.timer = undefined;
+      this.drain();
+    }, this.flushIntervalMs);
+  }
+  cancel() {
+    if (this.timer === undefined) return;
+    clearTimeout(this.timer);
+    this.timer = undefined;
+  }
+}
+
+/** Finite positive integers only; anything else falls back. */
+function positive(value, fallback) {
+  if (value === undefined) return fallback;
+  if (!Number.isSafeInteger(value) || value < 1) return fallback;
+  return value;
+}
+//# sourceMappingURL=NativeConsoleDestination.js.map

package/lib/module/destinations/NativeConsoleDestination.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["DefaultFormatter","LEVEL_ORDER","DEFAULT_BATCH_SIZE","DEFAULT_FLUSH_INTERVAL_MS","DEFAULT_MAX_PENDING","FAILURE_LIMIT","NativeConsoleDestination","levels","messages","disposed","failures","droppedEntries","constructor","sink","options","label","minimumLevel","formatter","batchSize","positive","flushIntervalMs","maxPending","maxPendingEntries","install","subsystem","category","isEnabled","dropped","write","entry","length","rendered","format","push","level","drain","arm","flush","_deadlineMs","dispose","cancel","logBatch","timer","undefined","setTimeout","clearTimeout","value","fallback","Number","isSafeInteger"],"sourceRoot":"../../../src","sources":["destinations/NativeConsoleDestination.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/destinations/types.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=types.js.map

package/lib/module/destinations/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["destinations/types.ts"],"mappings":"","ignoreList":[]}