@emdzej/bimmerz-logger 0.1.0

package/LICENSE

@@ -0,0 +1,131 @@
+# PolyForm Noncommercial License 1.0.0
+
+<https://polyformproject.org/licenses/noncommercial/1.0.0>
+
+## Acceptance
+
+In order to get any license under these terms, you must agree
+to them as both strict obligations and conditions to all
+your licenses.
+
+## Copyright License
+
+The licensor grants you a copyright license for the
+software to do everything you might do with the software
+that would otherwise infringe the licensor's copyright
+in it for any permitted purpose.  However, you may
+only distribute the software according to [Distribution
+License](#distribution-license) and make changes or new works
+based on the software according to [Changes and New Works
+License](#changes-and-new-works-license).
+
+## Distribution License
+
+The licensor grants you an additional copyright license
+to distribute copies of the software.  Your license
+to distribute covers distributing the software with
+changes and new works permitted by [Changes and New Works
+License](#changes-and-new-works-license).
+
+## Notices
+
+You must ensure that anyone who gets a copy of any part of
+the software from you also gets a copy of these terms or the
+URL for them above, as well as copies of any plain-text lines
+beginning with `Required Notice:` that the licensor provided
+with the software.  For example:
+
+> Required Notice: Copyright Yoyodyne, Inc. (http://example.com)
+
+## Changes and New Works License
+
+The licensor grants you an additional copyright license to
+make changes and new works based on the software for any
+permitted purpose.
+
+## Patent License
+
+The licensor grants you a patent license for the software that
+covers patent claims the licensor can license, or becomes able
+to license, that you would infringe by using the software.
+
+## Noncommercial Purposes
+
+Any noncommercial purpose is a permitted purpose.
+
+## Personal Uses
+
+Personal use for research, experiment, and testing for
+the benefit of public knowledge, personal study, private
+entertainment, hobby projects, amateur pursuits, or religious
+observance, without any anticipated commercial application,
+is use for a permitted purpose.
+
+## Noncommercial Organizations
+
+Use by any charitable organization, educational institution,
+public research organization, public safety or health
+organization, environmental protection organization,
+or government institution is use for a permitted purpose
+regardless of the source of funding or obligations resulting
+from the funding.
+
+## Fair Use
+
+You may have "fair use" rights for the software under the
+law. These terms do not limit them.
+
+## No Other Rights
+
+These terms do not allow you to sublicense or transfer any of
+your licenses to anyone else, or prevent the licensor from
+granting licenses to anyone else.  These terms do not imply
+any other licenses.
+
+## Patent Defense
+
+If you make any written claim that the software infringes or
+contributes to infringement of any patent, your patent license
+for the software granted under these terms ends immediately. If
+your company makes such a claim, your patent license ends
+immediately for work on behalf of your company.
+
+## Violations
+
+The first time you are notified in writing that you have
+violated any of these terms, or done anything with the software
+not covered by your licenses, your licenses can nonetheless
+continue if you come into full compliance with these terms,
+and take practical steps to correct past violations, within
+32 days of receiving notice.  Otherwise, all your licenses
+end immediately.
+
+## No Liability
+
+***As far as the law allows, the software comes as is, without
+any warranty or condition, and the licensor will not be liable
+to you for any damages arising out of these terms or the use
+or nature of the software, under any kind of legal claim.***
+
+## Definitions
+
+The **licensor** is the individual or entity offering these
+terms, and the **software** is the software the licensor makes
+available under these terms.
+
+**You** refers to the individual or entity agreeing to these
+terms.
+
+**Your company** is any legal entity, sole proprietorship,
+or other kind of organization that you work for, plus all
+organizations that have control over, are under the control of,
+or are under common control with that organization.  **Control**
+means ownership of substantially all the assets of an entity,
+or the power to direct its management and policies by vote,
+contract, or otherwise.  Control can be direct or indirect.
+
+**Your licenses** are all the licenses granted to you for the
+software under these terms.
+
+**Use** means anything you do with the software requiring one
+of your licenses.

package/README.md

@@ -0,0 +1,235 @@
+# @emdzej/bimmerz-logger
+
+Shared structured logger for the bimmerz family of tools
+([`ediabasx`](https://github.com/emdzej/ediabasx),
+[`inpax`](https://github.com/emdzej/inpax),
+[`ncsx`](https://github.com/emdzej/ncsx), and the apps that build on
+them).
+
+**Pino-shape API**, hierarchical categories, runtime-mutable central
+config, pluggable sinks. No environment variables. Works in both
+Node and the browser; tree-shake-friendly so web bundles don't ship
+pino.
+
+## TL;DR
+
+```ts
+import { configureLogger, getLogger } from '@emdzej/bimmerz-logger';
+
+// App start — configure once, anywhere.
+configureLogger({
+  level: 'info',
+  categories: {
+    EDIABASX: 'debug',
+    'EDIABASX.parser': 'trace',
+    INPAX: 'info',
+  },
+});
+
+// Anywhere in the codebase — log with or without a category.
+const log = getLogger('EDIABASX.parser');
+log.debug({ jobId: 'C_S_LESEN' }, 'parsing request packet');
+log.info('parser ready');
+
+// Want to flip on debug for one subsystem at runtime?
+configureLogger({ categories: { ...prev, INPAX: 'debug' } });
+// — every previously-handed-out INPAX logger sees the new level immediately.
+```
+
+## Design
+
+The interface is the same shape as pino — `log.debug(bindings, msg)`,
+levels `trace` through `fatal`, `log.child(bindings)`. We don't
+re-export pino's types because we don't want our public API locked
+to one implementation. The default sink is a small console wrapper
+(works in browser + Node); apps that want pino's pretty-print, JSON,
+or file destinations opt in via `@emdzej/bimmerz-logger/sinks/pino`.
+
+Logger handles are **proxies**, not snapshots — they consult the live
+config on every call. So once an app calls `configureLogger(…)`, every
+logger handle anyone ever cached picks up the new settings on its next
+emit. No need to "refetch" loggers from callers.
+
+Categories are **hierarchical** by dot. A rule for `EDIABASX` applies
+to `EDIABASX.parser` and `EDIABASX.parser.lexer` unless a more
+specific rule wins. Most specific match always wins:
+
+```ts
+configureLogger({
+  level: 'warn',
+  categories: {
+    EDIABASX: 'debug',          // covers EDIABASX, EDIABASX.runner, …
+    'EDIABASX.parser': 'trace', // overrides for parser sub-tree
+    INPAX: 'info',
+  },
+});
+
+getLogger('EDIABASX.parser.lexer').trace('hit');  // matches EDIABASX.parser → 'trace' → emitted
+getLogger('EDIABASX.runner').debug('hit');        // matches EDIABASX → 'debug' → emitted
+getLogger('INPAX.dispatcher').debug('miss');      // matches INPAX → 'info' → dropped
+getLogger().debug('miss');                        // root → 'warn' fallback → dropped
+```
+
+## API
+
+### `configureLogger(partial: Partial<LoggerConfig>)`
+
+Replace or merge into the active configuration. Shallow merge —
+`categories` and `sink` are replaced wholesale when present in the
+partial.
+
+```ts
+configureLogger({ level: 'debug' });                    // bump default level
+configureLogger({ categories: { EDIABASX: 'trace' } }); // change category rules
+configureLogger({ categories: {} });                    // clear all category rules
+```
+
+Apply early in your app's entry point. You can re-apply at any time
+— the change is immediate for every existing logger handle.
+
+### `getLogger(category?: string): Logger`
+
+Returns a logger handle. With no argument, the root logger
+(category = `null`). With a dot-separated string, a category-scoped
+logger.
+
+```ts
+const root = getLogger();
+const parser = getLogger('EDIABASX.parser');
+const job = parser.child({ jobId: 'C_S_LESEN' });
+```
+
+### `Logger`
+
+```ts
+interface Logger {
+  readonly level: LogLevel;     // currently-effective threshold (live)
+
+  trace(msg: string): void;
+  trace(bindings: object, msg: string): void;
+  debug(msg: string): void;
+  debug(bindings: object, msg: string): void;
+  info(msg: string): void;
+  info(bindings: object, msg: string): void;
+  warn(...): void;
+  error(...): void;
+  fatal(...): void;
+
+  child(bindings: object): Logger;
+}
+```
+
+Two call forms — string-only `log.info("done")`, or bindings-first
+`log.info({ jobId, count }, "done")`. Bindings are merged with any
+permanent `child()` bindings; call bindings win on key conflicts.
+
+`log.level` is a read-only getter that returns the live effective
+level for this logger's category. Cheap to call — use it as an
+escape hatch for hot paths where formatting the message is expensive:
+
+```ts
+if (log.level === 'trace') {
+  log.trace({ details: expensiveDump() }, 'sg op');
+}
+```
+
+### Sinks
+
+Bundled sinks (importable from the main entry):
+
+| Function | Use |
+|---|---|
+| `consoleSink({ colors?, relativeTime? })` | Default. Routes through `console.{debug,info,warn,error}`. ANSI colour when TTY. |
+| `bufferSink({ capacity? })` | In-memory ring of last N records. `.snapshot()` returns them — drives "Download log" UIs. |
+| `multiSink(a, b, …)` | Fan one record out to every wrapped sink. Failures in one sink don't poison the others. |
+| `nullSink()` | Drops everything. Tests, or to disable logging without changing level. |
+
+Optional pino sink — import from the subpath so it's not in the
+default tree-shake graph:
+
+```ts
+import { pinoSink } from '@emdzej/bimmerz-logger/sinks/pino';
+
+configureLogger({
+  level: 'info',
+  sink: pinoSink({ pretty: true }),     // pino-pretty when TTY
+  // or: pinoSink({ destination: '/var/log/app.log' })
+});
+```
+
+## Sink contract
+
+```ts
+interface Sink {
+  write(record: LogRecord): void;
+}
+
+interface LogRecord {
+  level: LogLevel;
+  category: string | null;
+  bindings: Record<string, unknown>;
+  msg: string;
+  time: number;  // Date.now()
+}
+```
+
+Roll your own sink for special destinations:
+
+```ts
+const httpSink: Sink = {
+  write(rec) {
+    if (rec.level === 'error' || rec.level === 'fatal') {
+      navigator.sendBeacon('/log', JSON.stringify(rec));
+    }
+  },
+};
+
+configureLogger({
+  sink: multiSink(consoleSink(), httpSink),
+});
+```
+
+## What we don't do
+
+- **No environment-variable reads.** Apps are responsible for
+  mapping their CLI flags / wizard config / settings panel onto
+  `configureLogger(…)`. Keeps the library portable and
+  predictable.
+- **No printf-style formatting.** Use template literals or
+  bindings:
+  ```ts
+  log.debug({ a, b }, 'compared');                   // ✅ bindings
+  log.debug(`compared ${a} vs ${b}`);                // ✅ template literal
+  log.debug({}, 'compared %s vs %s', a, b);          // ❌ not supported
+  ```
+- **No async sinks.** All sinks are sync. If you need network or
+  storage shipping, wrap a sync sink that enqueues to your own
+  async pipeline.
+
+## Migration from `@emdzej/ediabasx-logger` / `@emdzej/inpax-logger`
+
+Those packages will be retired once the codebases here are migrated.
+The shapes are similar — `configureLogger({...})` plus
+`getLogger("module")` — so most call sites need only an import path
+change:
+
+```ts
+// old
+import { getLogger, configureLogger } from '@emdzej/ediabasx-logger';
+// new
+import { getLogger, configureLogger } from '@emdzej/bimmerz-logger';
+```
+
+Behavioural differences worth knowing:
+
+- `configureLogger` now takes effect on **existing** logger handles.
+  ediabasx-logger only affected new ones.
+- pino types are no longer in the public surface. `Logger` is our own
+  interface (same shape). If you typed something as `pino.Logger`,
+  swap to `Logger` from this package.
+- `pretty` / `destination` options moved off the package-level config
+  and into the pino sink. Get them by switching the sink:
+  ```ts
+  import { pinoSink } from '@emdzej/bimmerz-logger/sinks/pino';
+  configureLogger({ sink: pinoSink({ pretty: true }) });
+  ```

package/dist/categories.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Hierarchical category resolution.
+ *
+ * Categories are dot-separated paths (`EDIABASX.parser.lexer`).
+ * `resolveLevel("EDIABASX.parser.lexer", rules, fallback)` walks up
+ * the path looking for a matching rule — `EDIABASX.parser.lexer`
+ * first, then `EDIABASX.parser`, then `EDIABASX`, then the
+ * fallback. First match wins.
+ *
+ * This is what makes "set INPAX to info, EDIABASX to debug, but
+ * EDIABASX.parser to trace" work without having to enumerate every
+ * subsystem in the rules.
+ */
+import type { LogLevel } from './types.js';
+/**
+ * Resolve the effective level for `category` given a rule map
+ * and a fallback. The root category — `null` or `''` — always
+ * gets the fallback (no rule can match an unnamed category).
+ */
+export declare function resolveLevel(category: string | null, rules: Readonly<Record<string, LogLevel>> | undefined, fallback: LogLevel): LogLevel;
+//# sourceMappingURL=categories.d.ts.map

package/dist/categories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"categories.d.ts","sourceRoot":"","sources":["../src/categories.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,MAAM,GAAG,IAAI,EACvB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,GAAG,SAAS,EACrD,QAAQ,EAAE,QAAQ,GACjB,QAAQ,CAYV"}

package/dist/categories.js

@@ -0,0 +1,36 @@
+/**
+ * Hierarchical category resolution.
+ *
+ * Categories are dot-separated paths (`EDIABASX.parser.lexer`).
+ * `resolveLevel("EDIABASX.parser.lexer", rules, fallback)` walks up
+ * the path looking for a matching rule — `EDIABASX.parser.lexer`
+ * first, then `EDIABASX.parser`, then `EDIABASX`, then the
+ * fallback. First match wins.
+ *
+ * This is what makes "set INPAX to info, EDIABASX to debug, but
+ * EDIABASX.parser to trace" work without having to enumerate every
+ * subsystem in the rules.
+ */
+import { LEVEL_VALUES } from './levels.js';
+/**
+ * Resolve the effective level for `category` given a rule map
+ * and a fallback. The root category — `null` or `''` — always
+ * gets the fallback (no rule can match an unnamed category).
+ */
+export function resolveLevel(category, rules, fallback) {
+    if (!rules || !category)
+        return fallback;
+    // Walk up dot segments: foo.bar.baz → foo.bar → foo → (fallback)
+    let path = category;
+    while (path.length > 0) {
+        const hit = rules[path];
+        if (hit !== undefined && hit in LEVEL_VALUES)
+            return hit;
+        const dot = path.lastIndexOf('.');
+        if (dot < 0)
+            break;
+        path = path.slice(0, dot);
+    }
+    return fallback;
+}
+//# sourceMappingURL=categories.js.map

package/dist/categories.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"categories.js","sourceRoot":"","sources":["../src/categories.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAG3C;;;;GAIG;AACH,MAAM,UAAU,YAAY,CAC1B,QAAuB,EACvB,KAAqD,EACrD,QAAkB;IAElB,IAAI,CAAC,KAAK,IAAI,CAAC,QAAQ;QAAE,OAAO,QAAQ,CAAC;IACzC,iEAAiE;IACjE,IAAI,IAAI,GAAG,QAAQ,CAAC;IACpB,OAAO,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACvB,MAAM,GAAG,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC;QACxB,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,IAAI,YAAY;YAAE,OAAO,GAAG,CAAC;QACzD,MAAM,GAAG,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;QAClC,IAAI,GAAG,GAAG,CAAC;YAAE,MAAM;QACnB,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;IAC5B,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `@emdzej/bimmerz-logger` — shared structured logger for the bimmerz
+ * family. See `README.md` for the design rationale and migration
+ * notes; the in-source doc on each export carries the API details.
+ *
+ * Pino-shape `Logger` interface, hierarchical category resolution,
+ * runtime-mutable central config, pluggable sink. Tree-shake-friendly
+ * — the default entry doesn't pull pino in, so web bundles stay light.
+ * Apps that want pino's JSON/pretty/file transports import the sink
+ * from `@emdzej/bimmerz-logger/sinks/pino`.
+ */
+export { configureLogger, getLogger, getLoggerConfig } from './logger.js';
+export { resolveLevel } from './categories.js';
+export { LEVEL_VALUES, levelPasses } from './levels.js';
+export { bufferSink, type BufferSink, type BufferSinkOptions } from './sinks/buffer.js';
+export { consoleSink, type ConsoleSinkOptions } from './sinks/console.js';
+export { multiSink } from './sinks/multi.js';
+export { nullSink } from './sinks/null.js';
+export type { LogBindings, LogLevel, LogRecord, Logger, LoggerConfig, Sink, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAUH,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC1E,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAExD,OAAO,EAAE,UAAU,EAAE,KAAK,UAAU,EAAE,KAAK,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACxF,OAAO,EAAE,WAAW,EAAE,KAAK,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAC1E,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAE3C,YAAY,EACV,WAAW,EACX,QAAQ,EACR,SAAS,EACT,MAAM,EACN,YAAY,EACZ,IAAI,GACL,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,25 @@
+/**
+ * `@emdzej/bimmerz-logger` — shared structured logger for the bimmerz
+ * family. See `README.md` for the design rationale and migration
+ * notes; the in-source doc on each export carries the API details.
+ *
+ * Pino-shape `Logger` interface, hierarchical category resolution,
+ * runtime-mutable central config, pluggable sink. Tree-shake-friendly
+ * — the default entry doesn't pull pino in, so web bundles stay light.
+ * Apps that want pino's JSON/pretty/file transports import the sink
+ * from `@emdzej/bimmerz-logger/sinks/pino`.
+ */
+import { setDefaultSink } from './logger.js';
+import { consoleSink } from './sinks/console.js';
+// Install the default sink at module load. Apps can override via
+// `configureLogger({ sink: … })` any time; this just ensures
+// imports that never call `configureLogger` still emit somewhere.
+setDefaultSink(consoleSink());
+export { configureLogger, getLogger, getLoggerConfig } from './logger.js';
+export { resolveLevel } from './categories.js';
+export { LEVEL_VALUES, levelPasses } from './levels.js';
+export { bufferSink } from './sinks/buffer.js';
+export { consoleSink } from './sinks/console.js';
+export { multiSink } from './sinks/multi.js';
+export { nullSink } from './sinks/null.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEjD,iEAAiE;AACjE,6DAA6D;AAC7D,kEAAkE;AAClE,cAAc,CAAC,WAAW,EAAE,CAAC,CAAC;AAE9B,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC1E,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAExD,OAAO,EAAE,UAAU,EAA2C,MAAM,mBAAmB,CAAC;AACxF,OAAO,EAAE,WAAW,EAA2B,MAAM,oBAAoB,CAAC;AAC1E,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/levels.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Level ordering + threshold helpers. Numeric values mirror pino's
+ * so a wrapping pino sink (or anyone comparing against pino's
+ * `logger.levels.values`) gets the same numbers back.
+ */
+import type { LogLevel } from './types.js';
+/**
+ * Numeric weight of each level. Higher = more severe. `silent` is
+ * `Infinity` so no record ever beats the threshold when the
+ * effective level is `silent`.
+ */
+export declare const LEVEL_VALUES: Record<LogLevel, number>;
+/**
+ * `true` when a record at `record` severity passes a `threshold`
+ * filter — i.e. the line should be emitted.
+ *
+ * Example: `levelPasses('debug', 'info')` → `false` (debug is below
+ * info). `levelPasses('error', 'info')` → `true`.
+ */
+export declare function levelPasses(record: LogLevel, threshold: LogLevel): boolean;
+//# sourceMappingURL=levels.d.ts.map

package/dist/levels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"levels.d.ts","sourceRoot":"","sources":["../src/levels.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C;;;;GAIG;AACH,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,QAAQ,EAAE,MAAM,CAQjD,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,QAAQ,GAAG,OAAO,CAE1E"}

package/dist/levels.js

@@ -0,0 +1,30 @@
+/**
+ * Level ordering + threshold helpers. Numeric values mirror pino's
+ * so a wrapping pino sink (or anyone comparing against pino's
+ * `logger.levels.values`) gets the same numbers back.
+ */
+/**
+ * Numeric weight of each level. Higher = more severe. `silent` is
+ * `Infinity` so no record ever beats the threshold when the
+ * effective level is `silent`.
+ */
+export const LEVEL_VALUES = {
+    trace: 10,
+    debug: 20,
+    info: 30,
+    warn: 40,
+    error: 50,
+    fatal: 60,
+    silent: Number.POSITIVE_INFINITY,
+};
+/**
+ * `true` when a record at `record` severity passes a `threshold`
+ * filter — i.e. the line should be emitted.
+ *
+ * Example: `levelPasses('debug', 'info')` → `false` (debug is below
+ * info). `levelPasses('error', 'info')` → `true`.
+ */
+export function levelPasses(record, threshold) {
+    return LEVEL_VALUES[record] >= LEVEL_VALUES[threshold];
+}
+//# sourceMappingURL=levels.js.map

package/dist/levels.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"levels.js","sourceRoot":"","sources":["../src/levels.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH;;;;GAIG;AACH,MAAM,CAAC,MAAM,YAAY,GAA6B;IACpD,KAAK,EAAE,EAAE;IACT,KAAK,EAAE,EAAE;IACT,IAAI,EAAE,EAAE;IACR,IAAI,EAAE,EAAE;IACR,KAAK,EAAE,EAAE;IACT,KAAK,EAAE,EAAE;IACT,MAAM,EAAE,MAAM,CAAC,iBAAiB;CACjC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,UAAU,WAAW,CAAC,MAAgB,EAAE,SAAmB;IAC/D,OAAO,YAAY,CAAC,MAAM,CAAC,IAAI,YAAY,CAAC,SAAS,CAAC,CAAC;AACzD,CAAC"}

package/dist/logger.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Logger implementation + central config.
+ *
+ * Logger handles are thin proxies that consult the live module-
+ * scoped config on every call. That's what makes
+ * `configureLogger({ categories: { EDIABASX: 'debug' } })` flip
+ * existing handles' behaviour instantly — no need to refetch
+ * loggers from callers.
+ *
+ * Performance: level resolution is a Map lookup + at most ~3 dot-
+ * segment slices for typical category paths. Both happen *before*
+ * any binding merge or sink dispatch, so a `log.debug({…}, 'msg')`
+ * call that's below threshold spends about as much time as a
+ * branch + Map.get. Same shape as pino's "no-op below level"
+ * pattern.
+ */
+import type { Logger, LoggerConfig, Sink } from './types.js';
+/** @internal — called from index.ts after sink modules load. */
+export declare function setDefaultSink(sink: Sink): void;
+/**
+ * Replace or merge into the active configuration. The merge is
+ * shallow — `categories` and `sink` are replaced wholesale when
+ * present in the partial. Pass `categories: {}` to clear all
+ * per-category overrides.
+ *
+ * Effective immediately for every logger handle, including ones
+ * already returned by `getLogger()`.
+ */
+export declare function configureLogger(config: Partial<LoggerConfig>): void;
+/**
+ * Snapshot of the active configuration. Returned object is a copy
+ * — mutating it doesn't affect the live config (use
+ * `configureLogger()` for that).
+ */
+export declare function getLoggerConfig(): Readonly<LoggerConfig>;
+/**
+ * Get a logger handle. Call with no arguments for the root logger
+ * (category = `null`); pass a dot-separated string to scope under
+ * a category. Re-calling with the same category does NOT return
+ * the same instance — handles are cheap, and shared identity would
+ * make `child()` bindings spill across callers.
+ *
+ * Examples:
+ *   const log = getLogger();
+ *   const parser = getLogger("EDIABASX.parser");
+ *   const job = parser.child({ jobId: "C_S_LESEN" });
+ */
+export declare function getLogger(category?: string): Logger;
+//# sourceMappingURL=logger.d.ts.map

package/dist/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,OAAO,KAAK,EAIV,MAAM,EACN,YAAY,EACZ,IAAI,EACL,MAAM,YAAY,CAAC;AASpB,gEAAgE;AAChE,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAE/C;AAOD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,OAAO,CAAC,YAAY,CAAC,GAAG,IAAI,CAInE;AAED;;;;GAIG;AACH,wBAAgB,eAAe,IAAI,QAAQ,CAAC,YAAY,CAAC,CAMxD;AAiED;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAEnD"}