@ckirg/corelib 0.1.22

package/dist/cloudflare-IOVZ3QEK.js

@@ -0,0 +1,102 @@
+import {
+  getSysInfo
+} from "./chunk-HPE2XSTW.js";
+
+// src/loggers/implementations/cloudflare.ts
+var LEVEL_MAP = {
+  trace: 10,
+  debug: 20,
+  info: 30,
+  warn: 40,
+  error: 50,
+  fatal: 60,
+  silent: Infinity
+};
+var CloudflareLogger = class _CloudflareLogger {
+  state;
+  context;
+  _level = process.env.LOG_LEVEL || "info";
+  constructor(state = { telemetryEnabled: false }, context = {}) {
+    this.state = state;
+    this.context = context;
+  }
+  getTelemetry() {
+    return this.state.telemetryEnabled ? getSysInfo() : void 0;
+  }
+  validate(msg, extras) {
+    if (typeof msg !== "string") {
+      throw new Error(
+        "Logger requires string message first, optional object second"
+      );
+    }
+    if (extras !== void 0 && (typeof extras !== "object" || extras === null || Array.isArray(extras))) {
+      throw new Error(
+        "Logger requires string message first, optional object second"
+      );
+    }
+  }
+  log(level, msg, extras) {
+    if ((LEVEL_MAP[level] ?? 30) < this.levelVal) return;
+    this.validate(msg, extras);
+    const output = {
+      level,
+      time: Date.now(),
+      ...this.context,
+      ...extras,
+      ...this.state.telemetryEnabled && { telemetry: this.getTelemetry() },
+      msg
+    };
+    console.log(JSON.stringify(output));
+  }
+  trace(msg, extras) {
+    this.log("trace", msg, extras);
+  }
+  debug(msg, extras) {
+    this.log("debug", msg, extras);
+  }
+  info(msg, extras) {
+    this.log("info", msg, extras);
+  }
+  warn(msg, extras) {
+    this.log("warn", msg, extras);
+  }
+  error(msg, extras) {
+    this.log("error", msg, extras);
+  }
+  fatal(msg, extras) {
+    this.log("fatal", msg, extras);
+  }
+  child(bindings) {
+    return new _CloudflareLogger(this.state, { ...this.context, ...bindings });
+  }
+  setTelemetry(mode) {
+    if (mode !== "on" && mode !== "off") {
+      throw new Error("setTelemetry accepts only 'on' or 'off'");
+    }
+    this.state.telemetryEnabled = mode === "on";
+  }
+  get level() {
+    return this._level;
+  }
+  set level(val) {
+    this._level = val;
+  }
+  get levelVal() {
+    return LEVEL_MAP[this._level] ?? 30;
+  }
+  bindings() {
+    return { ...this.context };
+  }
+  silent() {
+    this._level = "silent";
+  }
+  flush(cb) {
+    cb?.();
+  }
+};
+function createCloudflareLogger() {
+  return new CloudflareLogger();
+}
+export {
+  createCloudflareLogger as default
+};

package/dist/deno-MVIUW5GX.js

@@ -0,0 +1,41 @@
+import {
+  StrictLoggerWrapper
+} from "./chunk-HOOAMOFY.js";
+import "./chunk-HPE2XSTW.js";
+
+// src/loggers/implementations/deno.ts
+import { Writable } from "stream";
+import pino from "pino";
+import pretty from "pino-pretty";
+var isPretty = process.env.LOG_PRETTY === "true" || process.env.NODE_ENV !== "production" && process.env.LOG_PRETTY !== "false";
+var level = process.env.LOG_LEVEL || "info";
+var wsProxy = new Writable({
+  write(chunk, _encoding, cb) {
+    const fn = globalThis.__wsLogWrite;
+    if (fn) fn(typeof chunk === "string" ? chunk : chunk.toString("utf8"));
+    cb();
+  }
+});
+var dest = pino.multistream([
+  {
+    level,
+    stream: isPretty ? pretty({
+      colorize: true,
+      translateTime: "SYS:standard",
+      ignore: "pid,hostname"
+    }) : process.stdout
+  },
+  { level, stream: wsProxy }
+]);
+var pinoInstance = pino(
+  {
+    level,
+    redact: ["password", "secret", "token", "authorization", "apiKey"]
+  },
+  dest
+);
+var logger = new StrictLoggerWrapper(pinoInstance);
+var deno_default = logger;
+export {
+  deno_default as default
+};

package/dist/flight-recorder-BCSVZvWQ.d.ts

@@ -0,0 +1,92 @@
+declare global {
+    /**
+     * Global logger instance, if available.
+     */
+    var logger: StrictLogger | undefined;
+}
+/**
+ * Method signature for all log levels.
+ *
+ * @param {string} msg - The log message.
+ * @param {Record<string, unknown>} [extras] - Optional metadata to include with the log entry.
+ */
+type LogMethod = (msg: string, extras?: Record<string, unknown>) => void;
+/**
+ * StrictLogger Interface
+ * Defines a consistent API across all runtimes (Node, Bun, Deno, Cloudflare, etc.)
+ * This ensures that logging behavior is predictable and uniform regardless of the deployment target.
+ */
+interface StrictLogger {
+    /** Logs at the 'trace' level (most verbose). */
+    trace: LogMethod;
+    /** Logs at the 'debug' level. */
+    debug: LogMethod;
+    /** Logs at the 'info' level (default). */
+    info: LogMethod;
+    /** Logs at the 'warn' level. */
+    warn: LogMethod;
+    /** Logs at the 'error' level. */
+    error: LogMethod;
+    /** Logs at the 'fatal' level (highest priority). */
+    fatal: LogMethod;
+    /**
+     * Creates a child logger with additional bindings.
+     * Child loggers inherit the parent's configuration but add their own metadata.
+     *
+     * @param {Record<string, unknown>} bindings - Metadata to bind to all logs from the child logger.
+     * @returns {StrictLogger} A new logger instance.
+     */
+    child: (bindings: Record<string, unknown>) => StrictLogger;
+    /**
+     * Enables or disables system telemetry injection in log entries.
+     *
+     * @param {"on" | "off"} mode - The telemetry mode.
+     */
+    setTelemetry: (mode: "on" | "off") => void;
+    /** Current log level as a string (e.g., 'info', 'debug'). */
+    level: string;
+    /** Current log level as a numeric value. */
+    levelVal: number;
+    /**
+     * Returns the current bindings of the logger.
+     * @returns {Record<string, unknown>} The current bindings.
+     */
+    bindings: () => Record<string, unknown>;
+    /**
+     * Sets the log level to 'silent', disabling all output.
+     */
+    silent: () => void;
+    /**
+     * Flush any buffered log output (e.g. pino's sonic-boom buffer).
+     * Safe to call as a no-op when no buffer is in use.
+     *
+     * @param {(err?: Error | null) => void} [cb] - Optional callback called after flushing.
+     */
+    flush: (cb?: (err?: Error | null) => void) => void;
+}
+
+/**
+ * Returns the next process-wide monotonic correlation id. Used to pair a
+ * flight-recorder operation's start line (e.g. `query: exec`, `poll: start`)
+ * with its terminus (`query: ok` / `poll: done` / `*: error`). Cheap (one int++),
+ * globally unique across all corelib packages so two interleaved operations
+ * never share an id. For cross-operation tracing, pair this with a higher-level
+ * `traceId` threaded by the consuming application.
+ */
+declare function nextCid(): number;
+/**
+ * Core, strictly-typed flight-recorder extras. The named fields are fixed so an
+ * AI can grep them reliably; arbitrary extra keys carry domain detail.
+ */
+interface FlightRecorderExtras {
+    /** Correlation id pairing an operation's start with its terminus. */
+    cid?: number | string;
+    /** Wall-clock duration of the operation, in milliseconds (set on the terminus line). */
+    durationMs?: number;
+    /** What initiated the operation (cron name, route, event) — lets an AI trace up the stack. */
+    trigger?: string;
+    /** Domain-specific detail (symbol, account, counts, sample, errorMsg, …). */
+    [key: string]: unknown;
+}
+
+export { type FlightRecorderExtras as F, type LogMethod as L, type StrictLogger as S, nextCid as n };

package/dist/gcp-TRX5BADQ.js

@@ -0,0 +1,39 @@
+import {
+  StrictLoggerWrapper
+} from "./chunk-HOOAMOFY.js";
+import "./chunk-HPE2XSTW.js";
+
+// src/loggers/implementations/gcp.ts
+import * as gcpConfig from "@google-cloud/pino-logging-gcp-config";
+import pino from "pino";
+function createGcpLogger() {
+  try {
+    const configFactory = gcpConfig.createGcpLoggingPinoConfig || gcpConfig.default?.createGcpLoggingPinoConfig || gcpConfig.default;
+    if (typeof configFactory !== "function") {
+      throw new Error(
+        "Could not find createGcpLoggingPinoConfig function in @google-cloud/pino-logging-gcp-config"
+      );
+    }
+    const config = configFactory(
+      {},
+      // GCP options
+      {
+        level: process.env.LOG_LEVEL || "info",
+        timestamp: pino.stdTimeFunctions.isoTime,
+        redact: ["password", "secret", "token", "authorization"]
+      }
+    );
+    const pinoInstance = pino(config);
+    return new StrictLoggerWrapper(pinoInstance);
+  } catch (err) {
+    console.error("[GCP-LOGGER] Failed to initialize GCP logger:", err);
+    const fallback = pino({
+      level: process.env.LOG_LEVEL || "info",
+      timestamp: pino.stdTimeFunctions.isoTime
+    });
+    return new StrictLoggerWrapper(fallback);
+  }
+}
+export {
+  createGcpLogger as default
+};