loggily 0.0.1 → 0.3.0

package/.github/workflows/docs.yml

@@ -0,0 +1,58 @@
+name: Deploy Documentation
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - "docs/**"
+      - "src/**"
+      - ".github/workflows/docs.yml"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+concurrency:
+  group: pages
+  cancel-in-progress: false
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - name: Setup Pages
+        uses: actions/configure-pages@v4
+
+      - name: Install dependencies
+        run: bun install
+
+      - name: Build docs
+        run: bun run docs:build
+
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: docs/site/.vitepress/dist
+
+  deploy:
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4

package/.github/workflows/release.yml

@@ -0,0 +1,31 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+permissions:
+  contents: write
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+      - run: bun install
+      - run: bun test
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+          registry-url: 'https://registry.npmjs.org'
+      - run: npm publish --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          generate_release_notes: true

package/.github/workflows/test.yml

@@ -0,0 +1,20 @@
+name: Tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  workflow_dispatch:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+      - run: bun install
+      - run: bun run typecheck
+      - run: bun test

package/CHANGELOG.md

@@ -0,0 +1,45 @@
+# Changelog
+
+All notable changes to loggily will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.2.0] - 2026-03-04
+
+### Added
+
+- **Lazy messages** -- Pass `() => string` functions that are only called when the level is enabled
+- **Child context loggers** -- `log.child({ requestId: "abc" })` creates a logger with structured context fields in every message
+- **LOG_FORMAT env var** -- `LOG_FORMAT=json` explicitly enables structured JSON output
+- `setLogFormat()` / `getLogFormat()` -- Programmatic log format control
+- `setDebugFilter()` / `getDebugFilter()` -- Programmatic namespace filtering (like `DEBUG` env var)
+- **File writer** -- `createFileWriter(path, opts?)` for buffered file output with auto-flush
+- **Writer system** -- `addWriter(fn)` to subscribe to all formatted log output
+- `setOutputMode()` / `getOutputMode()` -- Control output destination (`console`, `stderr`, `writers-only`)
+- `setSuppressConsole()` -- Suppress console output while writers still receive
+- Comprehensive test suite (153 tests)
+
+### Changed
+
+- `createLogger()` now returns a `ConditionalLogger` directly (no separate function needed)
+- Improved documentation with full API reference and comparison guides
+
+## [0.1.0] - 2026-01-15
+
+### Added
+
+- Initial release
+- `createLogger(name, props?)` -- Create structured logger
+- Logger methods: `trace`, `debug`, `info`, `warn`, `error`
+- Child loggers with `.logger(namespace, props?)`
+- Span timing with `.span(namespace, props?)` and `using` keyword support
+- `SpanData` with id, traceId, parentId, startTime, endTime, duration
+- Custom span attributes via `span.spanData.key = value`
+- Configuration via environment variables: `LOG_LEVEL`, `TRACE`, `TRACE_FORMAT`
+- Programmatic configuration: `setLogLevel`, `getLogLevel`, `enableSpans`, `disableSpans`, `spansAreEnabled`
+- `setTraceFilter()` / `getTraceFilter()` -- Namespace-based span output control
+- Dual output format: pretty console (dev) and JSON (production)
+- Worker thread support: `createWorkerLogger`, `createWorkerLogHandler`, `forwardConsole`
+- Span collection for testing: `startCollecting`, `stopCollecting`, `getCollectedSpans`, `clearCollectedSpans`
+- `resetIds()` for deterministic tests

package/CLAUDE.md

@@ -0,0 +1,299 @@
+# loggily
+
+Structured logging with spans. Logger-first architecture: Span = Logger + Duration.
+
+## Quick Start
+
+```typescript
+import { createLogger } from "loggily"
+const log = createLogger("myapp")
+
+log.info("starting")
+log.error(new Error("failed"))
+
+// Spans for timing (implements Disposable)
+{
+  using span = log.span("import", { file: "data.csv" })
+  span.info("working...")
+  span.spanData.count = 42
+}
+// → SPAN myapp:import (15ms) {count: 42, file: "data.csv"}
+```
+
+## Environment Variables
+
+| Variable     | Values                                  | Effect                     |
+| ------------ | --------------------------------------- | -------------------------- |
+| LOG_LEVEL    | trace, debug, info, warn, error, silent | Filter output by level     |
+| DEBUG        | \*, namespace prefixes, -prefix         | Filter output by namespace |
+| TRACE        | 1, true, or namespace prefixes          | Enable span output         |
+| TRACE_FORMAT | json                                    | Force JSON output          |
+| NODE_ENV     | production                              | Auto-enable JSON format    |
+
+### Examples
+
+```bash
+LOG_LEVEL=debug bun run app         # Enable debug logging
+DEBUG=km:storage bun run app        # Only show km:storage (+ children), auto-enables debug level
+DEBUG='km:*,-km:sql' bun run app    # Show all km namespaces except km:sql
+DEBUG='*' bun run app               # Show all namespaces at debug level
+TRACE=1 bun run app                 # Enable all span timing output
+TRACE=myapp:import bun run app      # Enable spans for specific namespace
+TRACE=myapp,other bun run app       # Enable spans for multiple prefixes
+```
+
+## API
+
+### createLogger(name, props?)
+
+Create a logger. Props are inherited by children.
+
+```typescript
+const log = createLogger("myapp", { version: "1.0" })
+```
+
+### Logger Methods
+
+| Method                        | Purpose            |
+| ----------------------------- | ------------------ |
+| `.trace(msg, data?)`          | Verbose debugging  |
+| `.debug(msg, data?)`          | Debug information  |
+| `.info(msg, data?)`           | Normal operation   |
+| `.warn(msg, data?)`           | Recoverable issues |
+| `.error(msg \| Error, data?)` | Failures           |
+
+### Child Loggers
+
+```typescript
+// Extend namespace, inherit props
+const child = log.logger("import", { file: "data.csv" })
+// → namespace: "myapp:import", props: { version: "1.0", file: "data.csv" }
+
+// Create span (child with timing)
+{
+  using span = log.span("import")
+  span.info("working...")
+}
+```
+
+### Spans
+
+Spans are loggers with timing. They implement `Disposable` for use with `using`:
+
+```typescript
+{
+  using span = log.span("operation", { context: "value" })
+  span.debug("step 1")
+  span.spanData.processed = 100 // Set custom attributes
+}
+// On block exit: SPAN myapp:operation (15ms) {processed: 100, context: "value"}
+```
+
+For environments without `using` support, call `.end()` manually:
+
+```typescript
+const span = log.span("operation")
+try {
+  span.info("working...")
+  span.spanData.count = 42
+} finally {
+  span.end()
+}
+```
+
+### Span Data
+
+| Property             | Type                      | Description                           |
+| -------------------- | ------------------------- | ------------------------------------- |
+| `spanData.id`        | string (readonly)         | Unique span ID (sp_1, sp_2...)        |
+| `spanData.traceId`   | string (readonly)         | Trace ID (shared across nested spans) |
+| `spanData.parentId`  | string \| null (readonly) | Parent span ID                        |
+| `spanData.startTime` | number (readonly)         | Start timestamp (ms)                  |
+| `spanData.duration`  | number (readonly)         | Live duration since start             |
+| `spanData.custom`    | any (writable)            | Set custom attributes                 |
+
+### Configuration Functions
+
+```typescript
+import {
+  setLogLevel,
+  getLogLevel,
+  enableSpans,
+  disableSpans,
+  spansAreEnabled,
+  setTraceFilter,
+  getTraceFilter,
+  setDebugFilter,
+  getDebugFilter,
+} from "loggily"
+
+setLogLevel("debug") // Set minimum level
+getLogLevel() // Get current level: "debug"
+enableSpans() // Enable span output
+disableSpans() // Disable span output
+spansAreEnabled() // Check if spans are enabled
+setTraceFilter(["myapp"]) // Only output spans for "myapp" and "myapp:*"
+setTraceFilter(null) // Clear filter, output all spans
+getTraceFilter() // Get current filter: ["myapp"] or null
+setDebugFilter(["myapp"]) // Only show output for "myapp" and "myapp:*"
+setDebugFilter(["myapp", "-myapp:sql"]) // Show myapp but exclude myapp:sql
+setDebugFilter(null) // Clear filter, show all namespaces
+getDebugFilter() // Get current filter: ["myapp", "-myapp:sql"] or null
+```
+
+## Distributed Tracing (opt-in)
+
+### ID Format
+
+```typescript
+import { setIdFormat, getIdFormat } from "loggily"
+
+setIdFormat("simple") // sp_1, tr_1 (default)
+setIdFormat("w3c") // 16-char hex span, 32-char hex trace (W3C Trace Context)
+```
+
+### traceparent Header
+
+```typescript
+import { traceparent } from "loggily"
+
+const span = log.span("http-request")
+const header = traceparent(span.spanData)
+// → "00-a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6-1a2b3c4d5e6f7a8b-01"
+fetch(url, { headers: { traceparent: header } })
+```
+
+### Sampling
+
+```typescript
+import { setSampleRate, getSampleRate } from "loggily"
+
+setSampleRate(0.1) // Sample 10% of traces (head-based)
+setSampleRate(1.0) // Sample everything (default)
+```
+
+### Context Propagation (Node.js/Bun only)
+
+```typescript
+import { enableContextPropagation, getCurrentSpan } from "loggily/context"
+
+enableContextPropagation()
+
+const log = createLogger("myapp")
+{
+  using span = log.span("request")
+  // Logs auto-tagged with trace_id/span_id
+  log.info("handling") // includes trace_id, span_id in output
+
+  // Child spans from ANY logger auto-parent via AsyncLocalStorage
+  const other = createLogger("db")
+  const dbSpan = other.span("query") // parentId = span.id
+
+  getCurrentSpan() // { spanId, traceId, parentId }
+}
+```
+
+## Output Format
+
+### Console (development)
+
+```
+14:32:15 INFO myapp starting
+14:32:15 DEBUG myapp:import loading {file: "data.csv"}
+14:32:16 SPAN myapp:import (1234ms) {count: 42}
+```
+
+### JSON (production / TRACE_FORMAT=json)
+
+```json
+{"time":"2024-01-15T14:32:15.123Z","level":"info","name":"myapp","msg":"starting"}
+{"time":"2024-01-15T14:32:16.456Z","level":"span","name":"myapp:import","msg":"(1234ms)","duration":1234,"count":42}
+```
+
+## Zero-Overhead Pattern (Optional Chaining)
+
+`createLogger` returns `undefined` for disabled log levels, enabling zero-overhead logging.
+
+**Log levels** (most → least verbose): `trace < debug < info < warn < error < silent`
+**Default level**: `warn` for km CLI (trace, debug, and info disabled)
+
+```typescript
+import { createLogger } from "loggily"
+
+const log = createLogger("km:tui")
+
+// All methods support ?. for zero-overhead when their level is disabled
+log.trace?.(`very verbose: ${expensiveDebug()}`) // Skipped at default (warn)
+log.debug?.(`state: ${getState()}`) // Skipped at default (warn)
+log.info?.("starting") // Skipped at default (warn)
+log.warn?.("deprecated") // Enabled at default (warn)
+log.error?.("failed") // Enabled at default
+
+// With -v flag or LOG_LEVEL=info, info is enabled:
+log.info?.("starting") // Enabled when level=info
+```
+
+### Why optional chaining?
+
+**Benchmark results** (10M iterations, Bun 1.1.x):
+
+| Scenario                  | ops/s    | ns/op   | Notes                               |
+| ------------------------- | -------- | ------- | ----------------------------------- |
+| noop (cheap args)         | 2168M    | 0.5     | Fastest for trivial args            |
+| `?.` (cheap args)         | 1406M    | 0.7     | ~0.2ns overhead - negligible        |
+| noop (expensive args)     | 17M      | 57.6    | Args still evaluated - wasted!      |
+| **`?.` (expensive args)** | **408M** | **2.5** | Args NOT evaluated - **22x faster** |
+
+**Key insight**: Optional chaining is only ~0.2ns slower for cheap args, but **22x faster** for expensive args because it skips argument evaluation entirely.
+
+- `log.debug?.()` skips the entire call including argument evaluation when debug is disabled
+- TypeScript enforces `?.` at compile time (methods are typed as possibly undefined)
+- Main benefit: expensive string formatting and function calls are completely skipped
+
+See [docs/conditional-logging-research.md](docs/conditional-logging-research.md) for detailed research and external references.
+
+## Lazy Messages
+
+Messages can be functions — only called when the log level is enabled:
+
+```typescript
+log.debug?.(() => `expensive: ${JSON.stringify(bigObject)}`)
+// Function never called when debug is disabled
+```
+
+Type: `LazyMessage = string | (() => string)`
+
+## Child Context Loggers
+
+Create child loggers with additional structured context (not just namespace):
+
+```typescript
+const child = log.child({ requestId: "abc-123", userId: 42 })
+child.info?.("handling request")
+// → 14:32:15 INFO myapp handling request {requestId: "abc-123", userId: 42}
+```
+
+## JSON Output Format
+
+```bash
+LOG_FORMAT=json bun run app   # Force JSON output in any environment
+```
+
+In addition to `TRACE_FORMAT=json` and `NODE_ENV=production`, `LOG_FORMAT=json` explicitly enables structured JSON output.
+
+## File Writer
+
+```typescript
+import { createFileWriter } from "loggily"
+
+const writer = createFileWriter("/tmp/app.log")
+const log = createLogger("myapp", { writer })
+```
+
+## Best Practices
+
+1. **Namespace hierarchy**: Use `:` to create hierarchy (`myapp:db:query`)
+2. **Props for context**: Pass structured data, not string interpolation
+3. **Spans for timing**: Wrap operations you want to measure
+4. **Level filtering**: Use `LOG_LEVEL` to control verbosity
+5. **Conditional logging**: Use `?.` pattern in hot paths to skip arg evaluation

package/CONTRIBUTING.md

@@ -0,0 +1,58 @@
+# Contributing to loggily
+
+## Development Setup
+
+```bash
+git clone https://github.com/beorn/loggily.git
+cd logger
+bun install
+bun run test        # Run tests
+bun run typecheck   # Type check
+```
+
+## Code Style
+
+- TypeScript strict mode
+- ESM imports only (`import`/`export`, never `require`)
+- Factory functions over classes
+- Zero external dependencies
+
+## Testing
+
+All changes should include tests. Run the test suite before submitting:
+
+```bash
+bun run test
+```
+
+Tests must be silent on success. Use `vi.spyOn(console, 'log').mockImplementation(() => {})` to suppress output in tests.
+
+## Pull Requests
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Make your changes with tests
+4. Ensure `bun run test` and `bun run typecheck` pass
+5. Commit with [conventional commit](https://conventionalcommits.org/) messages
+6. Push and open a pull request
+
+## Commit Messages
+
+- `feat:` -- New features
+- `fix:` -- Bug fixes
+- `docs:` -- Documentation only
+- `test:` -- Test additions
+- `refactor:` -- Code changes that neither fix bugs nor add features
+- `chore:` -- Maintenance tasks
+
+## Design Principles
+
+1. **Logger-first** -- Spans are loggers with timing, not separate concepts
+2. **Minimal surface** -- Few, well-designed functions
+3. **Type safe** -- TypeScript enforces correct usage (e.g., `?.` for disabled levels)
+4. **Zero-cost** -- Optional chaining skips argument evaluation when disabled
+5. **Structured** -- JSON in production, readable console in development
+
+## Questions?
+
+Open an issue for discussion before starting large changes.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bjørn Stabell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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 THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,9 +1,108 @@
 # loggily
 
-Structured logging with context, levels, and formatting — the logger that gets out of your way.
+**Clarity without the clutter.**
 
-**Coming soon.**
+[![Tests](https://github.com/beorn/loggily/actions/workflows/test.yml/badge.svg)](https://github.com/beorn/loggily/actions/workflows/test.yml)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-blue.svg)](https://www.typescriptlang.org/)
+[![MIT License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+Debug logging, structured logs, and distributed tracing — integrated into one **~3KB** library with a single API. Zero dependencies.
+
+Most projects wire together three separate tools that don't talk to each other: **debug** for conditional output, **pino/winston** for production logs, **OpenTelemetry** for tracing. loggily integrates all three into one unified system — same namespace tree, same output pipeline, same `?.` zero-overhead pattern. Every logger is a potential span: call `.span()` and it becomes one, with automatic timing, parent-child tracking, and trace IDs. Nothing to sync, nothing to configure separately.
+
+In development, you get colorized console output with timestamps, level colors, and clickable source lines — loggily uses native `console` methods so stack traces stay intact in DevTools. In production, the same code emits structured JSON. No config change needed.
+
+Read **[The Journey](docs/guide.md)** for the full story.
+
+## Install
+
+```bash
+bun add loggily    # or: npm install loggily
+```
+
+## Quick Start
+
+```typescript
+import { createLogger } from "loggily"
+
+const log = createLogger("myapp")
+
+// ?. skips the entire call — including argument evaluation — when the level is disabled (near-zero cost)
+log.info?.("server started", { port: 3000 })
+log.debug?.("cache hit", { key: "user:42" })
+log.error?.(new Error("connection lost"))
+
+// Spans time operations automatically
+{
+  using span = log.span("db:query", { table: "users" })
+  const users = await db.query("SELECT * FROM users")
+  span.spanData.count = users.length
+}
+// Output: SPAN myapp:db:query (45ms) {count: 100, table: "users"}
+```
+
+## Why Another Logger?
+
+Beyond the integration story above, most loggers also waste work when logging is disabled. Even with a noop function, arguments are still evaluated:
+
+```typescript
+// Traditional — args are ALWAYS evaluated, even when debug is off
+log.debug(`state: ${JSON.stringify(computeExpensiveState())}`)
+```
+
+loggily uses optional chaining to skip the entire call — including argument evaluation:
+
+```typescript
+// loggily — args are NOT evaluated when disabled
+log.debug?.(`state: ${JSON.stringify(computeExpensiveState())}`)
+```
+
+For trivial arguments the difference is negligible. But for real-world logging — string interpolation, JSON serialization, state snapshots — optional chaining is typically **10x+ faster** because it skips the work entirely. The more expensive your arguments, the bigger the win.
+
+## Features
+
+- **Namespace hierarchy** — organize logs with `:` separators. `log.logger("db")` creates `myapp:db`. Children inherit parent context.
+- **Spans** — time any operation with `using span = log.span("name")`. Automatic duration, parent-child tracking, and trace IDs. _(Uses TC39 [Explicit Resource Management](https://github.com/tc39/proposal-explicit-resource-management); call `span.end()` manually if your runtime doesn't support `using` yet.)_
+- **Lazy messages** — `log.debug?.(() => expensiveString())` skips the function entirely when disabled.
+- **Child context** — `log.child({ requestId })` adds structured fields to every message in the chain.
+- **Dev & production** — colorized console with timestamps, level colors, and clickable source lines in development. Structured JSON in production. Switches automatically via `NODE_ENV` — same code, zero config.
+- **File writer** — `addWriter()` + `createFileWriter()` for buffered file output with auto-flush.
+- **Worker threads** — forward logs from workers to the main thread with full type safety (`loggily/worker`).
+- **Drop-in debug replacement** — reads `DEBUG=myapp:*` just like the debug package. Swap your imports in minutes.
+
+## Documentation
+
+- **[The Journey](docs/guide.md)** — progressive guide from first log to full observability
+- **[Full docs site](https://beorn.codes/loggily/)** — guides, API reference, migration guides
+- [Comparison](docs/comparison.md) — vs Pino, Winston, Bunyan, debug
+- [Migration from debug](docs/migration-from-debug.md) — step-by-step migration guide
+
+## Environment Variables
+
+| Variable       | Values                                  | Effect                                  |
+| -------------- | --------------------------------------- | --------------------------------------- |
+| `LOG_LEVEL`    | trace, debug, info, warn, error, silent | Minimum output level                    |
+| `LOG_FORMAT`   | console, json                           | Output format                           |
+| `DEBUG`        | `*`, namespace prefixes, `-prefix`      | Namespace filter (like `debug` package) |
+| `TRACE`        | `1`, `true`, or namespace prefixes      | Enable span output                      |
+| `TRACE_FORMAT` | json                                    | Force JSON for spans                    |
+| `NODE_ENV`     | production                              | Auto-enable JSON format                 |
+
+## API
+
+| Function                                                               | Description                                                   |
+| ---------------------------------------------------------------------- | ------------------------------------------------------------- |
+| `createLogger(name, props?)`                                           | Create a logger (disabled levels return `undefined` for `?.`) |
+| `.trace?.()` / `.debug?.()` / `.info?.()` / `.warn?.()` / `.error?.()` | Log at level (message + optional data)                        |
+| `.logger(namespace)`                                                   | Create child logger with extended namespace                   |
+| `.span(namespace, props?)`                                             | Create timed span (implements `Disposable`)                   |
+| `.child(context)`                                                      | Create child with structured context fields                   |
+| `addWriter(fn)` / `createFileWriter(path)`                             | Custom output writers                                         |
+| `setLogLevel()` / `setLogFormat()` / `enableSpans()`                   | Runtime configuration                                         |
+| `createWorkerLogger()` / `createWorkerLogHandler()`                    | Worker thread support (`loggily/worker`)                      |
+
+See the [full API reference](docs/api-reference.md) for all functions and options.
 
 ## License
 
-MIT
+[MIT](LICENSE)