@nxgt/telemetry 0.1.0 → 0.2.1

package/dist/attributes/attributes.d.ts

@@ -11,6 +11,13 @@ export type AttributeValue = AttributeScalar | readonly AttributeScalar[];
 export type Attributes = Readonly<Record<string, AttributeValue>>;
 /** Shared, frozen, and the one to return when there is nothing to say. */
 export declare const EMPTY_ATTRIBUTES: Attributes;
+/**
+ * What a value reads as when reading it threw. A getter that throws, a revoked
+ * Proxy and a `toString` that raises all arrive here — from application code,
+ * in a `catch`, which is exactly where a log must not become the second
+ * failure.
+ */
+export declare const UNREADABLE = "[unreadable]";
 /**
  * Whatever a caller passed, as something that can be indexed.
  *

package/dist/attributes/attributes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"attributes.d.ts","sourceRoot":"","sources":["../../src/attributes/attributes.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;AAE/D,MAAM,MAAM,cAAc,GAAG,eAAe,GAAG,SAAS,eAAe,EAAE,CAAC;AAE1E,MAAM,MAAM,UAAU,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC;AAElE,0EAA0E;AAC1E,eAAO,MAAM,gBAAgB,EAAE,UAA8B,CAAC;AAE9D;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,cAAc,CAwB9D;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAC3B,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,GAClD,UAAU,CAcZ;AAED,4EAA4E;AAC5E,wBAAgB,eAAe,CAC9B,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,UAAU,GACf,UAAU,CAKZ;AAED,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAEjE"}
+{"version":3,"file":"attributes.d.ts","sourceRoot":"","sources":["../../src/attributes/attributes.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;AAE/D,MAAM,MAAM,cAAc,GAAG,eAAe,GAAG,SAAS,eAAe,EAAE,CAAC;AAE1E,MAAM,MAAM,UAAU,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC;AAElE,0EAA0E;AAC1E,eAAO,MAAM,gBAAgB,EAAE,UAA8B,CAAC;AAE9D;;;;;GAKG;AACH,eAAO,MAAM,UAAU,iBAAiB,CAAC;AAEzC;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,cAAc,CAQ9D;AA4BD;;;;GAIG;AACH,wBAAgB,YAAY,CAC3B,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,GAClD,UAAU,CA+BZ;AAED,4EAA4E;AAC5E,wBAAgB,eAAe,CAC9B,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,UAAU,GACf,UAAU,CAKZ;AAED,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAEjE"}

package/dist/context/current.d.ts

@@ -0,0 +1,43 @@
+import { type Attributes } from '../attributes/attributes';
+import { type Telemetry } from '../telemetry/telemetry';
+import { type SpanContext } from '../trace/ids';
+/**
+ * What travels with the work: which telemetry is writing, which span is open,
+ * and the attributes everything inside inherits.
+ */
+export interface TelemetryContext {
+    readonly telemetry: Telemetry;
+    /** Absent between `withTelemetry` and the first `span`. */
+    readonly span?: SpanContext;
+    readonly attributes: Attributes;
+}
+export declare function currentContext(): TelemetryContext | undefined;
+/** Runs `fn` with `context` current, and restores whatever was there after. */
+export declare function runWithContext<T>(context: TelemetryContext, fn: () => T): T;
+/**
+ * The telemetry a logger or a span should write to: the one **in scope** first,
+ * the **installed** one second.
+ *
+ * That order is what lets two suites in one process each collect their own
+ * signals, and it is why `withTelemetry` exists.
+ */
+export declare function resolveTelemetry(): Telemetry | undefined;
+/** Runs `fn` with `telemetry` in scope, in place of the installed one. */
+export declare function withTelemetry<T>(telemetry: Telemetry, fn: () => T): T;
+/**
+ * Runs `fn` with these attributes inherited by every log and span inside it.
+ *
+ * With no context open but a telemetry installed — the top level of an
+ * application, before any span — it opens one, so the attributes reach the logs
+ * written there. With nothing installed either it runs `fn` unchanged:
+ * attaching attributes to nothing is not an error, and a library that does it
+ * must work in an application that has never heard of this one.
+ */
+export declare function withAttributes<T>(attributes: Readonly<Record<string, unknown>>, fn: () => T): T;
+/** The span open right here, if there is one. */
+export declare function currentSpan(): SpanContext | undefined;
+/** The header to send with an outgoing call, so the trace continues. */
+export declare function currentTraceparent(): string | undefined;
+/** The attributes everything written here inherits. */
+export declare function currentAttributes(): Attributes;
+//# sourceMappingURL=current.d.ts.map

package/dist/context/current.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"current.d.ts","sourceRoot":"","sources":["../../src/context/current.ts"],"names":[],"mappings":"AACA,OAAO,EACN,KAAK,UAAU,EAIf,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAsB,KAAK,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAC5E,OAAO,EAAqB,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAEnE;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAChC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,2DAA2D;IAC3D,QAAQ,CAAC,IAAI,CAAC,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;CAChC;AAoBD,wBAAgB,cAAc,IAAI,gBAAgB,GAAG,SAAS,CAE7D;AAED,+EAA+E;AAC/E,wBAAgB,cAAc,CAAC,CAAC,EAAE,OAAO,EAAE,gBAAgB,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAE3E;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,IAAI,SAAS,GAAG,SAAS,CAExD;AAED,0EAA0E;AAC1E,wBAAgB,aAAa,CAAC,CAAC,EAAE,SAAS,EAAE,SAAS,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAUrE;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAC/B,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAC7C,EAAE,EAAE,MAAM,CAAC,GACT,CAAC,CAcH;AAED,iDAAiD;AACjD,wBAAgB,WAAW,IAAI,WAAW,GAAG,SAAS,CAErD;AAED,wEAAwE;AACxE,wBAAgB,kBAAkB,IAAI,MAAM,GAAG,SAAS,CAGvD;AAED,uDAAuD;AACvD,wBAAgB,iBAAiB,IAAI,UAAU,CAE9C"}

package/dist/export/console.d.ts

@@ -0,0 +1,20 @@
+import type { Exporter } from './exporter';
+export interface ConsoleExporterOptions {
+    /** Where a line goes. Default: `console.log`. */
+    readonly write?: (line: string) => void;
+    /** Whether a recorded stack is printed under the line. Default true. */
+    readonly stackTraces?: boolean;
+}
+/**
+ * One line per signal, for a terminal.
+ *
+ * ```
+ * 10:04:22.318 INFO  CheckoutService  checkout.charged  orderId=o-1 amount=4200  [4bf92f35/00f067aa]
+ * 10:04:22.402 SPAN  charge  84ms  [4bf92f35/00f067aa]
+ * ```
+ *
+ * Errors go to the same stream as everything else: a log split across two
+ * streams is a log read in the wrong order.
+ */
+export declare function consoleExporter(options?: ConsoleExporterOptions): Exporter;
+//# sourceMappingURL=console.d.ts.map

package/dist/export/console.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console.d.ts","sourceRoot":"","sources":["../../src/export/console.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,MAAM,WAAW,sBAAsB;IACtC,iDAAiD;IACjD,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC,wEAAwE;IACxE,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAC9B,OAAO,GAAE,sBAA2B,GAClC,QAAQ,CAcV"}

package/dist/export/exporter.d.ts

@@ -0,0 +1,39 @@
+import type { Resource, Signal } from '../model/signal';
+/**
+ * Where a batch of signals goes.
+ *
+ * The contract, which the pipeline guarantees and an implementation may rely
+ * on:
+ *
+ * - **`export` is called from one consumer, never concurrently.** There is
+ *   nothing to synchronise, and a batch's order is the order things happened
+ *   in.
+ * - **It may take as long as it wants.** Nothing that writes a signal is
+ *   waiting on it.
+ * - **It should not throw.** If it does, the failure is reported to
+ *   `onExportError` and the next exporter still receives the batch: a
+ *   collector being down is not a reason for a request to fail.
+ *
+ * The `resource` comes with every call rather than through a start hook, rather
+ * than being fixed when the exporter is built — which is what lets one exporter
+ * serve two telemetries. Most exporters here hold nothing; `fileExporter` is
+ * the exception and says so.
+ */
+export interface Exporter {
+    /**
+     * Declared as a property rather than a method so TypeScript checks its
+     * parameters contravariantly: an implementation that asks for a mutable
+     * `Signal[]` is rejected, and a batch stays what arrived.
+     */
+    export: (resource: Resource, batch: readonly Signal[]) => void | Promise<void>;
+    /**
+     * Called once, after the last batch has drained. Optional.
+     *
+     * The one exception is a drain that ran out of time: `close` is then called
+     * while an `export` may still be in flight, because the alternative is a
+     * process that will not exit. The timeout is reported to `onExportError`
+     * first, so it is never silent.
+     */
+    close?: () => void | Promise<void>;
+}
+//# sourceMappingURL=exporter.d.ts.map

package/dist/export/exporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exporter.d.ts","sourceRoot":"","sources":["../../src/export/exporter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAExD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,QAAQ;IACxB;;;;OAIG;IACH,MAAM,EAAE,CACP,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,SAAS,MAAM,EAAE,KACpB,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE1B;;;;;;;OAOG;IACH,KAAK,CAAC,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACnC"}

package/dist/export/file.d.ts

@@ -0,0 +1,43 @@
+import type { Exporter } from './exporter';
+/** 64 MiB. */
+export declare const DEFAULT_MAX_SIZE: number;
+/** 24 hours, in milliseconds. Epoch-aligned, so it rolls at UTC midnight. */
+export declare const DEFAULT_ROTATION_PERIOD: number;
+export interface FileExporterOptions {
+    /** The file to append to. Its directory is created if it is missing. */
+    readonly path: string;
+    /** Roll at this many bytes. `0` disables it. Default 64 MiB. */
+    readonly maxSize?: number;
+    /** Roll when this period changes, in ms. `0` disables it. Default 24h. */
+    readonly every?: number;
+    /** How many rolled files to keep. Default 7. */
+    readonly keep?: number;
+    /** Gzip a rolled file. Default false. */
+    readonly compress?: boolean;
+    /** For specs. Default `Date.now`. */
+    readonly now?: () => number;
+}
+/**
+ * One JSON object per signal, appended to a file, with rotation.
+ *
+ * ```ts
+ * fileExporter({ path: 'logs/telemetry.jsonl', every: 0, maxSize: 8 * 1024 * 1024 })
+ * ```
+ *
+ * The same line format as `jsonLinesExporter`, so a shipper reads either. It
+ * **appends**: a restart continues the current file, and the period is read
+ * from that file's modification time rather than from when this process
+ * started, so a service that restarts hourly still rolls once a day.
+ *
+ * `close()` rolls nothing. A rolled file is a finished period, and a shutdown is
+ * not one.
+ *
+ * **This exporter owns its path.** It is the one stateful exporter here — it
+ * remembers the file's size and age rather than asking the filesystem on every
+ * batch — so give each path exactly one exporter. Calls are serialised
+ * internally, and any failure throws away what it remembered, so an external
+ * `logrotate` or a full disk costs the batch it happened on and nothing after
+ * it.
+ */
+export declare function fileExporter(options: FileExporterOptions): Exporter;
+//# sourceMappingURL=file.d.ts.map

package/dist/export/file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../src/export/file.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAU3C,cAAc;AACd,eAAO,MAAM,gBAAgB,QAAmB,CAAC;AACjD,6EAA6E;AAC7E,eAAO,MAAM,uBAAuB,QAAsB,CAAC;AAI3D,MAAM,WAAW,mBAAmB;IACnC,wEAAwE;IACxE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,gEAAgE;IAChE,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,0EAA0E;IAC1E,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,gDAAgD;IAChD,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,yCAAyC;IACzC,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B,qCAAqC;IACrC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CAC5B;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,QAAQ,CAgDnE"}

package/dist/export/json-lines.d.ts

@@ -0,0 +1,17 @@
+import type { Exporter } from './exporter';
+export interface JsonLinesExporterOptions {
+    /** Where a line goes. Default: `console.log`. */
+    readonly write?: (line: string) => void;
+}
+/**
+ * One JSON object per signal, one per line — the format `jq`, a log shipper and
+ * a collector's file receiver all read.
+ *
+ * The line is the signal as it is: `type` discriminates `"log"` from `"span"`,
+ * instants are epoch milliseconds, and absent fields are absent rather than
+ * null. **It does not carry the resource.** A file belongs to one service, so
+ * repeating its name on every line would be noise; an exporter that writes
+ * somewhere shared — `@nxgt/telemetry-mongo` — stamps it instead.
+ */
+export declare function jsonLinesExporter(options?: JsonLinesExporterOptions): Exporter;
+//# sourceMappingURL=json-lines.d.ts.map

package/dist/export/json-lines.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-lines.d.ts","sourceRoot":"","sources":["../../src/export/json-lines.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,MAAM,WAAW,wBAAwB;IACxC,iDAAiD;IACjD,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACxC;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAChC,OAAO,GAAE,wBAA6B,GACpC,QAAQ,CAWV"}

package/dist/export/pipeline.d.ts

@@ -0,0 +1,64 @@
+import type { Resource, Signal } from '../model/signal';
+import type { Exporter } from './exporter';
+export interface PipelineOptions {
+    readonly resource: Resource;
+    readonly exporters: readonly Exporter[];
+    /** Flush once this many signals are waiting. */
+    readonly batch: number;
+    /** Flush this many milliseconds after the first signal of a batch. */
+    readonly linger: number;
+    /** How long `close` waits for the backlog before giving up. */
+    readonly drainTimeout: number;
+    readonly onExportError: (failure: unknown) => void;
+}
+/**
+ * The queue between everything that writes a signal and everything that ships
+ * one.
+ *
+ * `post` is synchronous, total, and unbounded. A bounded queue would answer the
+ * back-pressure question by dropping signals or by blocking the application,
+ * and neither is an answer; an application that outruns its collector grows
+ * this array, which is visible in a heap profile, rather than losing the
+ * evidence of what it was doing.
+ *
+ * One consumer drains it, which is what lets the buffer be a plain array with
+ * no locking and what makes a batch's order the order things happened in.
+ */
+export declare class Pipeline {
+    private readonly options;
+    private buffer;
+    private timer;
+    /** The single consumer: every flush is chained onto the previous one. */
+    private draining;
+    private closed;
+    private closing;
+    constructor(options: PipelineOptions);
+    /**
+     * Never blocks, never throws, and answers whether the signal was taken.
+     * `false` means the pipeline is closed — the signal is dropped in silence,
+     * because a log must not become the reason a shutdown fails.
+     */
+    post(signal: Signal): boolean;
+    /**
+     * Stops accepting signals, ships what is waiting, and closes every
+     * exporter. Idempotent.
+     *
+     * It has to be awaited, and it is the one thing here that a caller waits
+     * for: a close that returned before the backlog shipped would lose exactly
+     * the signals a shutdown most needs to explain itself.
+     *
+     * **`drainTimeout` bounds the whole of it** — the drain and the exporters'
+     * own `close` together — so neither a collector that stopped answering nor
+     * an exporter that will not let go of its socket becomes the reason a
+     * process will not exit. A drain that runs out of time is reported to
+     * `onExportError`; see {@link Exporter} for what that suspends.
+     */
+    close(): Promise<void>;
+    private flush;
+    private clearTimer;
+    private ship;
+    private drainAndClose;
+    private closeExporters;
+    private report;
+}
+//# sourceMappingURL=pipeline.d.ts.map

package/dist/export/pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline.d.ts","sourceRoot":"","sources":["../../src/export/pipeline.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,MAAM,WAAW,eAAe;IAC/B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,SAAS,QAAQ,EAAE,CAAC;IACxC,gDAAgD;IAChD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,sEAAsE;IACtE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,+DAA+D;IAC/D,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,aAAa,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;CACnD;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,QAAQ;IACpB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkB;IAC1C,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,KAAK,CAA4C;IACzD,yEAAyE;IACzE,OAAO,CAAC,QAAQ,CAAoC;IACpD,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,OAAO,CAA4B;gBAE/B,OAAO,EAAE,eAAe;IAIpC;;;;OAIG;IACH,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAoB7B;;;;;;;;;;;;;OAaG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAKtB,OAAO,CAAC,KAAK;IAUb,OAAO,CAAC,UAAU;YAMJ,IAAI;YAUJ,aAAa;YA2Bb,cAAc;IAU5B,OAAO,CAAC,MAAM;CASd"}

package/dist/export/rotation.d.ts

@@ -0,0 +1,46 @@
+export interface RotationPolicy {
+    /** Roll once the file is at least this many bytes. 0 disables it. */
+    readonly maxSize: number;
+    /** Roll when this many milliseconds' period changes. 0 disables it. */
+    readonly every: number;
+    /** How many rolled files to keep. 0 keeps none. */
+    readonly keep: number;
+    readonly compress: boolean;
+}
+/**
+ * Whether the file open since `openedAt` should be rolled before the next
+ * write.
+ *
+ * **An empty file is never rolled**, whatever the clock says: rolling one
+ * produces an empty archive and resets the period, so an idle service would
+ * accumulate a directory of nothing.
+ *
+ * The period is **epoch-aligned** rather than measured from when the file was
+ * opened: `every: 24h` then rolls at UTC midnight, which is what somebody
+ * reading yesterday's file expects, instead of 24 hours after a restart.
+ */
+export declare function rotationDue(size: number, openedAt: number, now: number, policy: RotationPolicy): boolean;
+/**
+ * `telemetry.jsonl` rolled at that instant becomes
+ * `telemetry-20260915-100422.jsonl`, and `-1`, `-2`… if that name is taken.
+ * UTC, and no colons: the name has to survive every filesystem.
+ */
+export declare function rolledName(path: string, at: number, taken?: number): string;
+/**
+ * The rolled files of `path`, **newest first**. Anything else — the live file,
+ * another service's archives — is left alone.
+ *
+ * The order is taken from the parsed stamp and collision number, not from the
+ * name as text. Sorting the names would be wrong twice over within one second:
+ * the suffix is not fixed-width, so `-9` sorts after `-12`, and the unsuffixed
+ * name — which is the *oldest* of that second — sorts after every suffixed one,
+ * because `.` is above `-`.
+ *
+ * A gzipped archive and its plain twin are one period, and only the archive is
+ * listed: a `compress` whose cleanup failed must not make `keep` prune a period
+ * early.
+ */
+export declare function rolledOf(path: string, names: readonly string[]): string[];
+/** Which rolled files to delete, given how many to keep. */
+export declare function prunable(path: string, names: readonly string[], keep: number): string[];
+//# sourceMappingURL=rotation.d.ts.map

package/dist/export/rotation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rotation.d.ts","sourceRoot":"","sources":["../../src/export/rotation.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,cAAc;IAC9B,qEAAqE;IACrE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,uEAAuE;IACvE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,mDAAmD;IACnD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAC1B,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,cAAc,GACpB,OAAO,CAIT;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,SAAI,GAAG,MAAM,CAUtE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAoBzE;AAED,4DAA4D;AAC5D,wBAAgB,QAAQ,CACvB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,IAAI,EAAE,MAAM,GACV,MAAM,EAAE,CAOV"}

package/dist/index.d.ts

@@ -1,5 +1,19 @@
 export * from './attributes/attributes';
+export * from './context/current';
+export * from './export/console';
+export * from './export/exporter';
+export * from './export/file';
+export * from './export/json-lines';
+export type { PipelineOptions } from './export/pipeline';
+export * from './export/rotation';
+export * from './logger/event';
+export * from './logger/logger';
+export type { StandardSchemaV1 } from './logger/standard-schema';
+export * from './model/error';
 export * from './model/signal';
+export * from './span/scope';
+export * from './span/span';
+export * from './telemetry/telemetry';
 export * from './trace/ids';
 export * from './trace/sampler';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC;AAC9B,cAAc,qBAAqB,CAAC;AACpC,YAAY,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,YAAY,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,uBAAuB,CAAC;AACtC,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC"}