@voltro/logger 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,52 @@
+# Changelog
+
+All notable changes to the `@voltro/*` packages are recorded here. The format
+follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
+
+## Stability contract — read this before you pin a version
+
+Voltro is **`0.x` — pre-1.0, and deliberately so.** Under SemVer, `0.y.z` means
+"anything MAY change." We hold to exactly that, stated out loud:
+
+- **Pin exact versions.** Depend on `@voltro/runtime@0.4.2`, never `^0.4.2` or
+  `~0.4.2`. There is no compatible-range promise below 1.0.
+- **Every MINOR may break.** Breaking changes land on a minor bump (`0.4.x →
+  0.5.0`); patches (`0.4.1 → 0.4.2`) are additive or fixes only. This is the
+  standard `0.x` reading of SemVer — the minor slot carries breaking under `0.x`.
+- **Read this changelog before upgrading.** The `⚠ BREAKING` section of each
+  release lists every incompatible change with its migration. It is the only
+  migration path we provide — there is no deprecation cycle, no compat shim.
+- **All packages release together (lockstep).** One coordinated version across
+  the whole framework; the git tag is the source of truth.
+
+This is not a placeholder disclaimer — it is the contract. The framework is
+refactored aggressively while it has no external stability obligations, and that
+velocity is the point. A stable-core tier and per-package `1.0` graduation are
+planned, but not yet; until then, treat the whole surface as movable and pin
+exact.
+
+The **public API** of each package is its `publishConfig.exports` entry points,
+minus anything marked `@internal` (those are cross-package internals and are
+stripped from the published `.d.ts`). Importing a deep path that isn't an
+exported entry point is unsupported.
+
+---
+
+## [Unreleased]
+
+_Changes staged for the next release accumulate here (rolled up from
+`.changes/*.md` at tag time — see `.changes/README.md`)._
+
+---
+
+## [0.1.0]
+
+Initial pre-release baseline. This is the starting point the changelog tracks
+from; it is not an exhaustive history of prior development. The framework ships
+as `@voltro/*` packages spanning the runtime, database/query layer, web client
+and router, durable workflows, the CLI, and the plugin ecosystem
+(auth, storage, mail, billing, observability, and more). Not published to a
+public registry yet.
+
+Subsequent releases record their deltas from here under dated headings, with
+`⚠ BREAKING` first.

package/LICENSE

@@ -0,0 +1,57 @@
+Voltro — Proprietary Software License
+
+Copyright (c) 2026 Voltro UG. All rights reserved.
+
+This software and all associated source code, documentation, and other
+materials (the "Software") are the proprietary property of Voltro UG
+("Voltro"). This is NOT open-source software.
+
+Your access to and use of the Software is governed exclusively by the Voltro
+Terms of Service at:
+
+    https://voltro.cloud/legal/terms
+
+By downloading, installing, or using the Software you agree to those Terms.
+Subject to and conditioned on your continued compliance with them, Voltro
+grants you a limited, non-exclusive, non-transferable, non-sublicensable,
+revocable license to use the Software. All rights not expressly granted in the
+Terms are reserved by Voltro. If you do not agree to the Terms, you have no
+license and may not use the Software.
+
+The Terms of Service — including the scope of permitted use, plan
+entitlements, fees, and pricing — may change from time to time. The version in
+force is the one published at the URL above. Commercial terms and pricing are
+NOT part of this notice and are not fixed by, or granted in perpetuity by, the
+version of the Software in which this file appears.
+
+Permitted use — your own software. Voltro is a development framework. You may
+use the Software to build, run, and commercially distribute your own
+applications and services, and to charge your own customers for them, without
+owing Voltro any share of that revenue or any further permission beyond the
+Terms. Applications you build with the Software are yours.
+
+Prohibited use — reselling Voltro. You may NOT redistribute, resell,
+sublicense, publish, or otherwise provide the Software itself — in whole or in
+part, in source or compiled form — to third parties as a library, framework,
+SDK, template, starter, or development tool for them to build upon, whether
+standalone or repackaged. Shipping the Software as a non-separable, bundled
+dependency inside an application you deliver (for example, compiled into your
+deployed app) is permitted; extracting or re-exposing it as a reusable
+component for others is not.
+
+Except as expressly permitted above or by the Terms, you may not copy, modify,
+merge, publish, sublicense, sell, distribute, or create derivative works of the
+Software, in whole or in part.
+
+Third-party open-source components distributed alongside the Software are the
+property of their respective owners and are licensed under their own terms; see
+THIRD-PARTY-NOTICES.md where provided. Nothing in this notice limits your
+rights, or extends Voltro's, in those components.
+
+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
+VOLTRO BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY ARISING FROM,
+OUT OF, OR IN CONNECTION WITH THE SOFTWARE OR ITS USE.
+
+For licensing inquiries, contact Voltro UG.

package/README.md

@@ -0,0 +1,26 @@
+<div align="center">
+
+# @voltro/logger
+
+**Effect-based structured logger with pretty terminal output + JSON for production.**
+
+[📖 Documentation](https://docs.voltro.dev/docs/observability/overview) · [Changelog](./CHANGELOG.md) · [voltro.dev](https://voltro.dev) · [Voltro Cloud](https://voltro.cloud)
+
+</div>
+
+---
+
+```sh
+npm install @voltro/logger
+```
+
+> ### [→ Read the documentation for @voltro/logger](https://docs.voltro.dev/docs/observability/overview)
+
+Installation, guides, the full API reference, and examples all live in the
+**[Voltro documentation](https://docs.voltro.dev/docs/intro/getting-started)** — the single source of truth. This README is
+deliberately short so there is nothing here to drift out of date.
+
+## License
+
+Proprietary. © 2026 Voltro UG. Your use is governed by the
+[Terms of Service](https://voltro.cloud/legal/terms). See the bundled `LICENSE`.

package/SECURITY.md

@@ -0,0 +1,56 @@
+# Security Policy
+
+We take the security of Voltro and the applications built on it seriously. This
+document explains how to report a vulnerability and what to expect in return.
+
+## Reporting a vulnerability
+
+**Please do not open public issues or discuss suspected vulnerabilities in
+public channels.** Report them privately by email:
+
+**security contact: [support@voltro.dev](mailto:support@voltro.dev)**
+(subject line: `SECURITY`).
+
+Include, where you can:
+
+- the affected package(s) and version(s) (e.g. `@voltro/runtime@x.y.z`);
+- a description of the issue and its impact;
+- a minimal reproduction or proof of concept;
+- any suggested remediation.
+
+If you'd like to encrypt your report, ask in a first plain email and we'll
+arrange a key.
+
+## What to expect
+
+- **Acknowledgement** of your report within **3 business days**.
+- An initial assessment (severity, affected surface) and a remediation plan as
+  soon as we've reproduced the issue.
+- **Coordinated disclosure:** we'll agree a disclosure timeline with you and
+  credit you in the release notes if you wish. Please give us reasonable time to
+  ship a fix before any public disclosure.
+
+We do not currently run a paid bug-bounty program, but we genuinely appreciate
+responsible disclosure and will credit reporters.
+
+## Software Bill of Materials (SBOM)
+
+A CycloneDX SBOM of the third-party runtime dependency graph is generated for the
+published packages (`pnpm gen:sbom` → `sbom.cdx.json`). If your procurement or
+security team needs it, request it at
+[support@voltro.dev](mailto:support@voltro.dev).
+
+## Supported versions
+
+Voltro is pre-1.0 and ships in lockstep: **only the latest published minor of
+each `@voltro/*` package receives security fixes.** Please upgrade to the latest
+release before reporting, and pin exact versions in production.
+
+## Scope
+
+In scope: the published `@voltro/*` packages and the framework's own code.
+
+Out of scope: vulnerabilities in third-party dependencies that are already
+tracked upstream (we monitor these via a production-dependency audit gate in
+CI), and issues that require a non-default, explicitly-unsafe configuration. If
+you're unsure, report it anyway — we'd rather hear about it.

package/THIRD-PARTY-NOTICES.md

@@ -0,0 +1,11 @@
+# Third-Party Notices — @voltro/logger
+
+This package depends on the open-source software listed below. Each is the
+property of its respective copyright holders and is used under the terms of
+its license. This file is provided for attribution; it grants no rights in
+@voltro/logger itself, which is proprietary (see LICENSE).
+
+Generated from the resolved runtime dependency closure (0 packages).
+
+---
+

package/dist/index.d.ts

@@ -0,0 +1,298 @@
+import { Layer } from 'effect';
+import { Logger } from 'effect';
+import { LogLevel as LogLevel_2 } from 'effect';
+
+export declare const addSink: (fn: LogSink) => (() => void);
+
+export declare const ansi: {
+    reset: string;
+    dim: (s: string) => string;
+    bold: (s: string) => string;
+    italic: (s: string) => string;
+    gray: (s: string) => string;
+    red: (s: string) => string;
+    green: (s: string) => string;
+    yellow: (s: string) => string;
+    blue: (s: string) => string;
+    magenta: (s: string) => string;
+    cyan: (s: string) => string;
+    white: (s: string) => string;
+    brightRed: (s: string) => string;
+    brightGreen: (s: string) => string;
+    brightYellow: (s: string) => string;
+    brightBlue: (s: string) => string;
+    brightCyan: (s: string) => string;
+    bgRed: (s: string) => string;
+    bgYellow: (s: string) => string;
+    bgBlue: (s: string) => string;
+    bgCyan: (s: string) => string;
+    bgGray: (s: string) => string;
+    brand: (s: string) => string;
+    brandDim: (s: string) => string;
+    bgBrand: (s: string) => string;
+    red24: (s: string) => string;
+    brightRed24: (s: string) => string;
+};
+
+export declare type AppKind = 'web' | 'api' | 'preview';
+
+export declare interface AppSurfaceOptions {
+    readonly appName: string;
+    readonly queries: ReadonlyArray<string>;
+    readonly mutations: ReadonlyArray<string>;
+    readonly actions: ReadonlyArray<string>;
+    readonly streams?: ReadonlyArray<string>;
+    readonly workflows: ReadonlyArray<string>;
+    /** Cron schedules (`*.cron.tsx` discovery). Rendered as its own
+     *  category alongside the rpc primitives so the boot surface shows
+     *  the WHOLE app at a glance — not just the request-driven half. */
+    readonly schedules?: ReadonlyArray<string>;
+    /** Materialised aggregates (`*.aggregate.ts` discovery). Same
+     *  motivation as schedules — they're part of the app's surface even
+     *  though no rpc tag points at them. */
+    readonly aggregates?: ReadonlyArray<string>;
+    /** Event triggers (`*.trigger.tsx`) — rendered as `event→workflow`. */
+    readonly triggers?: ReadonlyArray<string>;
+    /** Agents (`*.agent.tsx`) — each synthesizes `<name>.send` + `.messages`. */
+    readonly agents?: ReadonlyArray<string>;
+    /** Public REST routes (`*.route.tsx` / `restRoutes`) — `METHOD /path`. */
+    readonly restRoutes?: ReadonlyArray<string>;
+    /** Non-wire lifecycle primitives. Shown count-only because their
+     *  names load later in boot (after this banner, which prints BEFORE
+     *  the risky seed/startup runs on purpose). */
+    readonly lifecycle?: {
+        readonly seeds?: number;
+        readonly startups?: number;
+        readonly subscribers?: number;
+        readonly webhooks?: number;
+        readonly emails?: number;
+    };
+    readonly tenantTables?: ReadonlyArray<string>;
+}
+
+export declare interface BufferedSink<T> {
+    /** Buffer an item. Applies the `maxBuffer` drop-oldest guard, then the
+     *  `admit` early-flush policy. */
+    readonly push: (item: T) => void;
+    /** Drain + ship whatever is buffered right now. Fail-soft — never
+     *  throws; a `send` failure is routed to `onError`. A no-op when empty. */
+    readonly flush: () => Promise<void>;
+    /** Stop the timer + do one final best-effort drain. Idempotent —
+     *  call it from a plugin's `onDeactivate`. */
+    readonly dispose: () => Promise<void>;
+}
+
+/**
+ * What `admit` decides for each pushed item. The helper appends the item
+ * to the buffer, then consults `admit` to decide whether the buffer must
+ * flush NOW (a size / byte budget crossed) — the buffer is handed in so
+ * the policy can measure it however it likes.
+ */
+export declare interface BufferedSinkOptions<T> {
+    /** Flush interval in ms — the periodic timer fires `flush` this often. */
+    readonly intervalMs: number;
+    /**
+     * Ship a drained batch. MAY reject/throw — the helper catches it and
+     * routes it to `onError`, so a backend outage never propagates into the
+     * app. Called with the whole drained batch; an empty batch is never
+     * passed (the helper short-circuits).
+     */
+    readonly send: (batch: ReadonlyArray<T>) => Promise<void> | void;
+    /**
+     * Consulted BEFORE the incoming item is appended, with the CURRENT
+     * (non-empty) buffer. Return `true` to ship what's buffered FIRST so the
+     * outgoing batch stays under a budget (logship's byte cap), then start a
+     * fresh batch with the incoming item. Only called when the buffer is
+     * non-empty. Omit when no pre-append flush is needed.
+     */
+    readonly flushBefore?: (buffer: ReadonlyArray<T>, incoming: T) => boolean;
+    /**
+     * Consulted AFTER the item was appended. Return `'flush'` to ship the
+     * buffered batch immediately (a count budget was reached), or `'keep'`
+     * to leave it buffered for the timer. Omit for pure interval-only
+     * batching. The buffer passed in INCLUDES the just-appended item.
+     */
+    readonly admit?: (buffer: ReadonlyArray<T>, added: T) => 'flush' | 'keep';
+    /**
+     * Hard cap on buffered items — when exceeded, the OLDEST item is
+     * dropped (a ring buffer) so an unreachable backend can't grow the
+     * buffer without bound. Omit for no cap (rely on `admit` + interval).
+     */
+    readonly maxBuffer?: number;
+    /** Fail-soft error reporter — receives any error `send` produced. The
+     *  app keeps running regardless; this is purely for a warn line. */
+    readonly onError?: (error: unknown, batchSize: number) => void;
+}
+
+export declare const createLogger: (config?: SyncLoggerConfig) => SyncLogger;
+
+/**
+ * True when stdout looks like an interactive TTY. We use this to
+ * auto-disable colours on plain pipes / file redirection / CI runs.
+ */
+export declare const isTty: () => boolean;
+
+export declare const jsonFormat: (record: LogRecord) => string;
+
+/**
+ * Default logger instance — useful for one-off scripts that don't
+ * want to manage their own. Has no scope; consumers can `.child(…)`
+ * to specialise.
+ */
+export declare const log: SyncLogger;
+
+export declare interface LoggerConfig {
+    readonly format?: 'pretty' | 'json';
+    readonly colour?: boolean;
+    /** With `LoggerLayer` this sets the runtime minimum log level
+     *  (`Logger.minimumLogLevel`, env default). A bare `makeLogger`
+     *  honours it too — an explicit `minLevel` drops sub-threshold
+     *  entries inside the logger; unset, the Effect runtime's minimum
+     *  governs (so `Logger.withMinimumLogLevel` keeps working). */
+    readonly minLevel?: LogLevel_2.LogLevel;
+    /** Default scope tag applied when an annotation doesn't set one. */
+    readonly defaultScope?: string;
+    /** Opt-in: mask any field (or nested value, or plain-object cause)
+     *  whose KEY matches one of these (case-insensitive). OFF by default.
+     *  Mirrors the sync `createLogger` surface so both code paths redact. */
+    readonly redactKeys?: ReadonlyArray<string>;
+    /** Opt-in: a custom record→record transform applied before the record
+     *  is formatted. Runs after `redactKeys`. */
+    readonly redact?: Redactor;
+}
+
+/**
+ * Ready-to-install layer. Replaces the default Effect logger + sets
+ * the minimum log level from `VOLTRO_LOG_LEVEL`. Apps just add this
+ * to their main Layer chain:
+ *
+ *     const Main = Layer.mergeAll(
+ *       LoggerLayer({ defaultScope: 'voltro:cli' }),
+ *       OtherLayers,
+ *     )
+ */
+export declare const LoggerLayer: (config?: LoggerConfig) => Layer.Layer<never>;
+
+export declare type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+
+export declare interface LogRecord {
+    readonly ts: Date;
+    readonly level: LogLevel;
+    /** Optional logical scope ("voltro:cli", "@voltro-cloud/api", …). */
+    readonly scope?: string;
+    /** Optional Effect fiber id for correlating across async boundaries. */
+    readonly fiberId?: string;
+    readonly message: string;
+    /** Free-form structured fields. Effect logger annotations end up here. */
+    readonly fields: Readonly<Record<string, unknown>>;
+    /** Captured error (`cause` annotation from Effect) — separate so the
+     *  formatters can format it specially (stack trace etc.). */
+    readonly cause?: unknown;
+}
+
+declare type LogSink = (record: LogRecord) => void;
+
+/**
+ * Build a buffered sink: a bounded buffer drained on an interval and on
+ * demand, fail-soft, with a final drain on dispose. See
+ * `BufferedSinkOptions` for the buffer-membership hooks each consumer
+ * customises.
+ */
+export declare const makeBufferedSink: <T>(options: BufferedSinkOptions<T>) => BufferedSink<T>;
+
+/**
+ * Build a `Redactor` that masks every field (and nested object/array
+ * value, and plain-object `cause`) whose KEY matches one of `keys`
+ * (case-insensitive). Matched values become `options.mask`
+ * (default `'[redacted]'`).
+ *
+ *     createLogger({ redactKeys: ['password', 'apiKey', 'authorization'] })
+ *
+ * Note: `cause` values that are `Error` INSTANCES are passed through
+ * unchanged — masking an Error's internals would break the pretty
+ * stack rendering, and an Error's own enumerable props are diagnostic
+ * (name / message / pg-driver fields), not secret-keyed config. Put a
+ * secret in a `fields` entry, not in an Error you throw, if you want
+ * it masked.
+ */
+export declare const makeKeyRedactor: (keys: ReadonlyArray<string>, options?: {
+    readonly mask?: string;
+}) => Redactor;
+
+export declare const makeLogger: (config?: LoggerConfig) => Logger.Logger<unknown, void>;
+
+export declare const prettyFormat: (record: LogRecord, options?: PrettyFormatOptions) => string;
+
+export declare interface PrettyFormatOptions {
+    /** When false, suppress every ANSI code (file sinks, redirected stdout). */
+    readonly colour?: boolean;
+    /** Suppress the scope tag (when the consumer is a single app). */
+    readonly hideScope?: boolean;
+}
+
+export declare const printAppSurface: (options: AppSurfaceOptions) => void;
+
+/**
+ * Print the ready block to stdout. Idempotent — safe to call once
+ * per boot. Always emits a trailing newline so the next prompt /
+ * log line starts clean.
+ */
+export declare const printReadyBlock: (options: ReadyBlockOptions) => void;
+
+export declare interface ReadyBlockOptions {
+    /** App's human-readable name (`app.config.ts.name`). */
+    readonly app: string;
+    readonly kind: AppKind;
+    /** Primary URL — appears on its own line, brand-styled. */
+    readonly url: string;
+    /** Optional extra URLs (admin, ws, inspector). Listed below the primary. */
+    readonly extras?: ReadonlyArray<{
+        readonly label: string;
+        readonly url: string;
+    }>;
+    /** Boot duration in milliseconds (start of boot → ready). */
+    readonly bootMs: number;
+}
+
+/** A pure transform applied to a record before it is formatted / fanned out. */
+export declare type Redactor = (record: LogRecord) => LogRecord;
+
+/**
+ * Strip ANSI sequences from a string. Useful when the same payload
+ * is being emitted to a file sink that doesn't grok escape codes.
+ */
+export declare const stripAnsi: (s: string) => string;
+
+export declare interface SyncLogger {
+    readonly trace: (msg: string, fields?: Record<string, unknown>) => void;
+    readonly debug: (msg: string, fields?: Record<string, unknown>) => void;
+    readonly info: (msg: string, fields?: Record<string, unknown>) => void;
+    readonly warn: (msg: string, fields?: Record<string, unknown>, cause?: unknown) => void;
+    readonly error: (msg: string, fields?: Record<string, unknown>, cause?: unknown) => void;
+    readonly fatal: (msg: string, fields?: Record<string, unknown>, cause?: unknown) => void;
+    /** Child logger with merged scope + fields. Useful for "every log
+     *  from this sub-system gets `{ component: 'codegen' }` baked in".
+     *  Pass `options.minLevel` to raise (or lower) verbosity for JUST this
+     *  sub-system — e.g. `log.child('codegen', {}, { minLevel: 'debug' })`
+     *  keeps the rest of the app at `info` while the codegen scope traces. */
+    readonly child: (scope: string, fields?: Record<string, unknown>, options?: {
+        readonly minLevel?: LogLevel;
+    }) => SyncLogger;
+}
+
+export declare interface SyncLoggerConfig {
+    readonly scope?: string;
+    readonly fields?: Record<string, unknown>;
+    readonly format?: 'pretty' | 'json';
+    readonly colour?: boolean;
+    readonly minLevel?: LogLevel;
+    /** Opt-in: mask any field (or nested value, or plain-object cause)
+     *  whose KEY matches one of these (case-insensitive). OFF by default. */
+    readonly redactKeys?: ReadonlyArray<string>;
+    /** Opt-in: a custom record→record transform applied before the record
+     *  is formatted AND before the sink fan-out (so a masked value never
+     *  reaches stdout OR a downstream sink). Runs after `redactKeys`. */
+    readonly redact?: Redactor;
+}
+
+export { }

package/dist/index.js

@@ -0,0 +1,498 @@
+import { Cause as e, FiberId as t, HashMap as n, Layer as r, List as i, LogLevel as a, Logger as o } from "effect";
+//#region src/ansi.ts
+var s = "\x1B[", c = `${s}0m`, l = (e) => (t) => `${e}${t}${c}`, u = {
+	reset: c,
+	dim: l(`${s}2m`),
+	bold: l(`${s}1m`),
+	italic: l(`${s}3m`),
+	gray: l(`${s}90m`),
+	red: l(`${s}31m`),
+	green: l(`${s}32m`),
+	yellow: l(`${s}33m`),
+	blue: l(`${s}34m`),
+	magenta: l(`${s}35m`),
+	cyan: l(`${s}36m`),
+	white: l(`${s}37m`),
+	brightRed: l(`${s}91m`),
+	brightGreen: l(`${s}92m`),
+	brightYellow: l(`${s}93m`),
+	brightBlue: l(`${s}94m`),
+	brightCyan: l(`${s}96m`),
+	bgRed: l(`${s}41m`),
+	bgYellow: l(`${s}43m`),
+	bgBlue: l(`${s}44m`),
+	bgCyan: l(`${s}46m`),
+	bgGray: l(`${s}100m`),
+	brand: l(`${s}38;2;166;140;255m`),
+	brandDim: l(`${s}38;2;124;101;208m`),
+	bgBrand: l(`${s}48;2;103;78;204m`),
+	red24: l(`${s}38;2;220;38;38m`),
+	brightRed24: l(`${s}38;2;239;68;68m`)
+}, d = (e) => e.replace(/\x1b\[[0-9;]*m/g, ""), f = () => {
+	try {
+		return !!process.stdout.isTTY;
+	} catch {
+		return !1;
+	}
+}, p = "[redacted]", m = (e, t, n, r) => {
+	if (typeof e != "object" || !e || e instanceof Error || r.has(e)) return e;
+	if (r.add(e), Array.isArray(e)) return e.map((e) => m(e, t, n, r));
+	let i = {};
+	for (let [a, o] of Object.entries(e)) i[a] = t.has(a.toLowerCase()) ? n : m(o, t, n, r);
+	return i;
+}, h = (e, t = {}) => {
+	let n = new Set(e.map((e) => e.toLowerCase())), r = t.mask ?? p;
+	return n.size === 0 ? (e) => e : (e) => {
+		let t = m(e.fields, n, r, /* @__PURE__ */ new WeakSet()), i = {
+			...e,
+			fields: t
+		};
+		return e.cause === void 0 ? i : {
+			...i,
+			cause: m(e.cause, n, r, /* @__PURE__ */ new WeakSet())
+		};
+	};
+}, g = (e) => {
+	let t = e.redactKeys && e.redactKeys.length > 0 ? h(e.redactKeys) : void 0, n = e.redact;
+	return t && n ? (e) => n(t(e)) : t ?? n;
+}, _ = (e) => e < 10 ? `0${e}` : String(e), v = (e) => e < 10 ? `00${e}` : e < 100 ? `0${e}` : String(e), y = (e) => `${_(e.getHours())}:${_(e.getMinutes())}:${_(e.getSeconds())}.${v(e.getMilliseconds())}`, b = (e) => typeof e == "object" && !!e && !Array.isArray(e), x = (e) => {
+	if (e === null) return "null";
+	if (e === void 0) return "undefined";
+	if (typeof e == "string") return /[\s"=]/.test(e) ? JSON.stringify(e) : e;
+	if (typeof e == "number" || typeof e == "boolean") return String(e);
+	if (e instanceof Date) return e.toISOString();
+	try {
+		return JSON.stringify(e);
+	} catch {
+		return String(e);
+	}
+}, S = {
+	trace: (e) => u.dim(u.gray(e.toUpperCase().padEnd(5))),
+	debug: (e) => u.cyan(e.toUpperCase().padEnd(5)),
+	info: (e) => u.brand(e.toUpperCase().padEnd(5)),
+	warn: (e) => u.yellow(e.toUpperCase().padEnd(5)),
+	error: (e) => u.brightRed24(e.toUpperCase().padEnd(5)),
+	fatal: (e) => u.bgRed(u.brightRed24(` ${e.toUpperCase()} `))
+}, C = (e, t = {}) => {
+	let n = t.colour ?? !0, r = n ? u : k, i = r.dim(y(e.ts)), a = n ? S[e.level](e.level) : e.level.toUpperCase().padEnd(5), o = !t.hideScope && e.scope ? `${r.dim("[")}${r.brandDim(e.scope)}${r.dim("]")}` : "", s = [];
+	for (let [t, n] of Object.entries(e.fields)) s.push(`${r.dim(`${t}=`)}${x(n)}`);
+	let c = e.fiberId ? r.dim(`fiber=${e.fiberId}`) : "", l = [...s, c].filter((e) => e.length > 0).join(" "), d = [
+		i,
+		a,
+		o,
+		e.message,
+		l
+	].filter((e) => e.length > 0).join(" ");
+	if (e.cause !== void 0) {
+		let t = w(e.cause, n);
+		return t.length > 0 ? `${d}\n${t}` : d;
+	}
+	return d;
+}, w = (e, t) => {
+	let n = t ? u : k;
+	if (e instanceof Error) {
+		let t = n.red(`  ${e.name}: ${e.message}`);
+		if (typeof e.stack == "string") {
+			let r = e.stack.split("\n").slice(1).map((e) => n.dim(`  ${e.trim()}`)).join("\n");
+			return r.length > 0 ? `${t}\n${r}` : t;
+		}
+		return t;
+	}
+	if (b(e) && typeof e.stack == "string") {
+		let [t, ...r] = e.stack.split("\n"), i = n.red(`  ${t ?? ""}`), a = r.map((e) => n.dim(`  ${e.trimEnd()}`)).join("\n");
+		return a.length > 0 ? `${i}\n${a}` : i;
+	}
+	if (b(e)) try {
+		return n.red(`  ${JSON.stringify(e, null, 2).replace(/\n/g, "\n  ")}`);
+	} catch {
+		return n.red(`  ${String(e)}`);
+	}
+	return n.red(`  ${String(e)}`);
+}, T = [
+	"severity",
+	"code",
+	"detail",
+	"hint",
+	"position",
+	"internalPosition",
+	"internalQuery",
+	"where",
+	"schema",
+	"table",
+	"column",
+	"dataType",
+	"constraint",
+	"file",
+	"line",
+	"routine"
+], E = (e, t = 0, n = /* @__PURE__ */ new WeakSet()) => {
+	if (t > 8) return "[cause: max-depth]";
+	if (typeof e != "object" || !e) return e;
+	if (n.has(e)) return "[cause: circular]";
+	if (n.add(e), e instanceof Error) {
+		let r = {
+			name: e.name,
+			message: e.message
+		};
+		typeof e.stack == "string" && (r.stack = e.stack);
+		let i = e;
+		for (let e of T) {
+			let t = i[e];
+			t !== void 0 && (r[e] = t);
+		}
+		return "cause" in e && e.cause !== void 0 && (r.cause = E(e.cause, t + 1, n)), r;
+	}
+	if (Array.isArray(e)) return e.map((e) => E(e, t + 1, n));
+	let r = {};
+	for (let [i, a] of Object.entries(e)) r[i] = E(a, t + 1, n);
+	return r;
+}, D = (e) => {
+	let t = {};
+	for (let [n, r] of Object.entries(e.fields)) t[n] = E(r);
+	let n = {
+		ts: e.ts.toISOString(),
+		level: e.level,
+		msg: e.message,
+		...e.scope ? { scope: e.scope } : {},
+		...e.fiberId ? { fiberId: e.fiberId } : {},
+		...t
+	};
+	e.cause !== void 0 && (n.cause = E(e.cause));
+	try {
+		return JSON.stringify(n);
+	} catch {
+		return JSON.stringify({
+			ts: n.ts,
+			level: n.level,
+			msg: n.msg,
+			...n.scope ? { scope: n.scope } : {},
+			_serialiseError: !0
+		});
+	}
+}, O = (e) => e, k = {
+	reset: "",
+	dim: O,
+	bold: O,
+	italic: O,
+	gray: O,
+	red: O,
+	green: O,
+	yellow: O,
+	blue: O,
+	magenta: O,
+	cyan: O,
+	white: O,
+	brightRed: O,
+	brightGreen: O,
+	brightYellow: O,
+	brightBlue: O,
+	brightCyan: O,
+	bgRed: O,
+	bgYellow: O,
+	bgBlue: O,
+	bgCyan: O,
+	bgGray: O,
+	brand: O,
+	brandDim: O,
+	bgBrand: O,
+	red24: O,
+	brightRed24: O
+}, A = /* @__PURE__ */ new Set(), j = (e) => (A.add(e), () => {
+	A.delete(e);
+}), M = (e) => {
+	if (A.size !== 0) for (let t of A) try {
+		t(e);
+	} catch {}
+}, ee = () => {
+	let e = (process.env.VOLTRO_LOG_FORMAT ?? "").toLowerCase();
+	return e === "pretty" ? "pretty" : e === "json" ? "json" : f() ? "pretty" : "json";
+}, N = () => {
+	let e = (process.env.VOLTRO_LOG_COLOUR ?? "").toLowerCase();
+	return e === "on" || e === "true" || e === "1" ? !0 : e === "off" || e === "false" || e === "0" ? !1 : f();
+}, P = () => {
+	switch ((process.env.VOLTRO_LOG_LEVEL ?? "").toLowerCase()) {
+		case "trace": return a.Trace;
+		case "debug": return a.Debug;
+		case "info": return a.Info;
+		case "warn": return a.Warning;
+		case "error": return a.Error;
+		case "fatal": return a.Fatal;
+		default: {
+			let e = (process.env.NODE_ENV ?? "").toLowerCase();
+			return e !== "production" && e !== "prod" ? a.Debug : a.Info;
+		}
+	}
+}, F = (e) => {
+	switch (e.label) {
+		case "TRACE": return "trace";
+		case "DEBUG": return "debug";
+		case "INFO": return "info";
+		case "WARN": return "warn";
+		case "ERROR": return "error";
+		case "FATAL": return "fatal";
+		default: return "info";
+	}
+}, I = (r) => {
+	let a = {}, o;
+	n.forEach(r.annotations, (e, t) => {
+		if (t === "scope" && typeof e == "string") {
+			o = e;
+			return;
+		}
+		a[t] = e;
+	});
+	let s = [];
+	i.forEach(r.spans, (e) => {
+		s.push(e.label);
+	}), s.length > 0 && (a.span = s.join("."));
+	let c = r.fiberId !== void 0 && r.fiberId !== null && t.threadName(r.fiberId) || void 0, l = r.cause !== void 0 && r.cause !== null ? e.isEmpty(r.cause) ? void 0 : e.squash(r.cause) : void 0, u = L(r.message);
+	return {
+		ts: new Date(r.date.getTime()),
+		level: F(r.logLevel),
+		message: u,
+		fields: a,
+		...o ? { scope: o } : {},
+		...c ? { fiberId: c } : {},
+		...l === void 0 ? {} : { cause: l }
+	};
+}, L = (e) => typeof e == "string" ? e : Array.isArray(e) ? e.map((e) => typeof e == "string" ? e : e === void 0 ? "undefined" : e === null ? "null" : typeof e == "object" ? R(e) : String(e)).join(" ") : e === void 0 ? "" : e === null ? "null" : typeof e == "object" ? R(e) : String(e), R = (e) => {
+	try {
+		return JSON.stringify(e);
+	} catch {
+		return String(e);
+	}
+}, z = (e, t) => {
+	(e.level === "error" || e.level === "fatal" ? process.stderr : process.stdout).write(`${t}\n`);
+}, B = (e, t, n) => t === "json" ? D(e) : C(e, n), V = (e = {}) => {
+	let t = e.format ?? ee(), n = { colour: e.colour ?? N() }, r = g(e), i = e.minLevel;
+	return o.make((o) => {
+		if (i !== void 0 && a.lessThan(o.logLevel, i)) return;
+		let s = I(o), c = !s.scope && e.defaultScope ? {
+			...s,
+			scope: e.defaultScope
+		} : s, l = r ? r(c) : c;
+		z(l, B(l, t, n)), M(l);
+	});
+}, H = (e = {}) => r.mergeAll(o.replace(o.defaultLogger, V(e)), o.minimumLogLevel(e.minLevel ?? P())), U = {
+	trace: 10,
+	debug: 20,
+	info: 30,
+	warn: 40,
+	error: 50,
+	fatal: 60
+}, W = (e) => {
+	try {
+		return typeof process < "u" && process.env && process.env[e] || "";
+	} catch {
+		return "";
+	}
+}, G = () => {
+	let e = W("VOLTRO_LOG_FORMAT").toLowerCase();
+	return e === "pretty" ? "pretty" : e === "json" ? "json" : f() ? "pretty" : "json";
+}, K = () => {
+	let e = W("VOLTRO_LOG_COLOUR").toLowerCase();
+	return e === "on" || e === "true" || e === "1" ? !0 : e === "off" || e === "false" || e === "0" ? !1 : f();
+}, q = () => {
+	let e = W("VOLTRO_LOG_LEVEL").toLowerCase();
+	if (e === "trace" || e === "debug" || e === "info" || e === "warn" || e === "error" || e === "fatal") return e;
+	let t = W("NODE_ENV").toLowerCase();
+	return t !== "production" && t !== "prod" ? "debug" : "info";
+}, J = globalThis.window !== void 0;
+if (!J && typeof process < "u") for (let e of [process.stdout, process.stderr]) e && typeof e.on == "function" && e.on("error", (e) => {
+	if (e?.code !== "EPIPE") throw e;
+});
+var Y = (e, t, n, r) => {
+	let i = r ? r(e) : e;
+	if (J) {
+		let e = t === "json" ? D(i) : C(i, {
+			...n,
+			colour: !1
+		});
+		(console[X(i.level)] ?? console.log).call(console, e);
+	} else {
+		let e = t === "json" ? D(i) : C(i, n), r = i.level === "error" || i.level === "fatal" ? process.stderr : process.stdout;
+		try {
+			r.write(`${e}\n`);
+		} catch {}
+	}
+	M(i);
+}, X = (e) => {
+	switch (e) {
+		case "trace":
+		case "debug": return "debug";
+		case "info": return "log";
+		case "warn": return "warn";
+		case "error":
+		case "fatal": return "error";
+	}
+}, Z = (e = {}) => {
+	let t = e.format ?? G(), n = e.colour ?? K(), r = U[e.minLevel ?? q()], i = e.fields ?? {}, a = e.scope, o = g(e), s = (e, s, c, l) => {
+		U[e] < r || Y({
+			ts: /* @__PURE__ */ new Date(),
+			level: e,
+			...a ? { scope: a } : {},
+			message: s,
+			fields: {
+				...i,
+				...c ?? {}
+			},
+			...l === void 0 ? {} : { cause: l }
+		}, t, { colour: n }, o);
+	};
+	return {
+		trace: (e, t) => s("trace", e, t),
+		debug: (e, t) => s("debug", e, t),
+		info: (e, t) => s("info", e, t),
+		warn: (e, t, n) => s("warn", e, t, n),
+		error: (e, t, n) => s("error", e, t, n),
+		fatal: (e, t, n) => s("fatal", e, t, n),
+		child: (t, n, r) => Z({
+			...e,
+			scope: a ? `${a}:${t}` : t,
+			fields: {
+				...i,
+				...n ?? {}
+			},
+			...r?.minLevel === void 0 ? {} : { minLevel: r.minLevel }
+		})
+	};
+}, Q = Z(), te = (e) => {
+	let t = [], n, r = !1, i = async () => {
+		if (t.length === 0) return;
+		let n = t.splice(0, t.length);
+		try {
+			await e.send(n);
+		} catch (t) {
+			e.onError?.(t, n.length);
+		}
+	};
+	return n = setInterval(() => void i(), e.intervalMs), typeof n.unref == "function" && n.unref(), {
+		push: (n) => {
+			r || (e.flushBefore && t.length > 0 && e.flushBefore(t, n) && i(), t.push(n), e.maxBuffer !== void 0 && t.length > e.maxBuffer && t.shift(), e.admit && e.admit(t, n) === "flush" && i());
+		},
+		flush: i,
+		dispose: async () => {
+			if (r) {
+				await i();
+				return;
+			}
+			r = !0, n && clearInterval(n), n = void 0, await i(), t = [];
+		}
+	};
+}, ne = {
+	web: "Web app",
+	api: "API app",
+	preview: "Preview"
+}, re = (e) => e < 1e3 ? `${Math.round(e)} ms` : `${(e / 1e3).toFixed(1)} s`, ie = (e) => {
+	let t = f() ? u : ae(), n = [];
+	n.push(""), n.push(`  ${t.brand("▲")}  ${t.bold("Voltro")} ${t.dim("·")} ${t.dim(ne[e.kind])} ${t.dim("·")} ${e.app}`), n.push(""), n.push(`  ${t.dim("➜")}  ${t.dim("Local:  ")}${t.bold(t.brand(e.url))}`);
+	for (let r of e.extras ?? []) {
+		let e = `${r.label}:`.padEnd(8, " ");
+		n.push(`  ${t.dim("➜")}  ${t.dim(e)}${t.brandDim(r.url)}`);
+	}
+	n.push(""), n.push(`  ${t.dim(`ready in ${re(e.bootMs)}`)}`), n.push(""), process.stdout.write(n.join("\n") + "\n");
+}, ae = () => {
+	let e = (e) => e;
+	return {
+		reset: "",
+		dim: e,
+		bold: e,
+		italic: e,
+		gray: e,
+		red: e,
+		green: e,
+		yellow: e,
+		blue: e,
+		magenta: e,
+		cyan: e,
+		white: e,
+		brightRed: e,
+		brightGreen: e,
+		brightYellow: e,
+		brightBlue: e,
+		brightCyan: e,
+		bgRed: e,
+		bgYellow: e,
+		bgBlue: e,
+		bgCyan: e,
+		bgGray: e,
+		brand: e,
+		brandDim: e,
+		bgBrand: e,
+		red24: e,
+		brightRed24: e
+	};
+}, $ = (e) => {
+	let t = /* @__PURE__ */ new Map();
+	for (let n of e) {
+		let e = n.indexOf("."), r = e >= 0 ? n.slice(0, e) : "(top)", i = e >= 0 ? n.slice(e + 1) : n, a = t.get(r);
+		a ? a.push(i) : t.set(r, [i]);
+	}
+	return [...t.entries()].sort(([e], [t]) => e.localeCompare(t)).map(([e, t]) => ({
+		namespace: e,
+		operations: t.slice().sort()
+	}));
+}, oe = (e) => {
+	let t = f() ? u : se(), n = e.schedules ?? [], r = e.aggregates ?? [], i = e.streams ?? [], a = e.triggers ?? [], o = e.agents ?? [], s = e.restRoutes ?? [], c = e.lifecycle ?? {}, l = (c.seeds ?? 0) + (c.startups ?? 0) + (c.subscribers ?? 0) + (c.webhooks ?? 0) + (c.emails ?? 0);
+	if (e.queries.length + e.mutations.length + e.actions.length + i.length + e.workflows.length + n.length + r.length + a.length + o.length + s.length + l === 0) return;
+	let d = [""], p = [
+		...$(e.queries).map((e) => e.namespace),
+		...$(e.mutations).map((e) => e.namespace),
+		...$(e.actions).map((e) => e.namespace),
+		...$(i).map((e) => e.namespace),
+		...$(e.workflows).map((e) => e.namespace),
+		...$(n).map((e) => e.namespace),
+		...$(r).map((e) => e.namespace),
+		...$(a).map((e) => e.namespace),
+		...$(o).map((e) => e.namespace)
+	].reduce((e, t) => Math.max(e, t.length), 0), m = (e, n) => {
+		if (n.length !== 0) {
+			d.push(`  ${t.bold(e)} ${t.dim(`(${n.length})`)}`);
+			for (let { namespace: e, operations: r } of $(n)) {
+				let n = e.padEnd(p, " ");
+				d.push(`    ${t.brand(n)} ${t.dim("·")} ${r.join(t.dim(", "))}`);
+			}
+			d.push("");
+		}
+	};
+	if (m("Queries", e.queries), m("Mutations", e.mutations), m("Actions", e.actions), m("Streams", i), m("REST routes", s), m("Workflows", e.workflows), m("Triggers", a), m("Schedules", n), m("Agents", o), m("Aggregates", r), l > 0) {
+		let e = [], n = (t, n, r) => {
+			t && t > 0 && e.push(`${t} ${t === 1 ? n : r}`);
+		};
+		n(c.seeds, "seed", "seeds"), n(c.startups, "startup", "startups"), n(c.subscribers, "subscriber", "subscribers"), n(c.webhooks, "webhook", "webhooks"), n(c.emails, "email", "emails"), d.push(`  ${t.bold("Lifecycle")} ${t.dim("·")} ${e.join(t.dim(" · "))}`), d.push("");
+	}
+	e.tenantTables && e.tenantTables.length > 0 && (d.push(`  ${t.dim("Tenant-scoped tables")} ${t.dim("·")} ${e.tenantTables.join(t.dim(", "))}`), d.push("")), process.stdout.write(d.join("\n"));
+}, se = () => {
+	let e = (e) => e;
+	return {
+		reset: "",
+		dim: e,
+		bold: e,
+		italic: e,
+		gray: e,
+		red: e,
+		green: e,
+		yellow: e,
+		blue: e,
+		magenta: e,
+		cyan: e,
+		white: e,
+		brightRed: e,
+		brightGreen: e,
+		brightYellow: e,
+		brightBlue: e,
+		brightCyan: e,
+		bgRed: e,
+		bgYellow: e,
+		bgBlue: e,
+		bgCyan: e,
+		bgGray: e,
+		brand: e,
+		brandDim: e,
+		bgBrand: e,
+		red24: e,
+		brightRed24: e
+	};
+};
+//#endregion
+export { H as LoggerLayer, j as addSink, u as ansi, Z as createLogger, f as isTty, D as jsonFormat, Q as log, te as makeBufferedSink, h as makeKeyRedactor, V as makeLogger, C as prettyFormat, oe as printAppSurface, ie as printReadyBlock, d as stripAnsi };

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@voltro/logger",
+  "version": "0.1.0",
+  "description": "Effect-based structured logger with pretty terminal output + JSON for production.",
+  "keywords": [
+    "voltro",
+    "typescript",
+    "framework"
+  ],
+  "license": "SEE LICENSE IN LICENSE",
+  "homepage": "https://voltro.dev",
+  "bugs": {
+    "email": "support@voltro.dev"
+  },
+  "author": {
+    "name": "Voltro UG",
+    "url": "https://voltro.dev"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "peerDependencies": {
+    "effect": "^3.21.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}