@c9up/ream 0.2.7 → 0.2.9

package/src/commands/MigrateRollback.ts

@@ -0,0 +1,18 @@
+/** `migrate:rollback` — undo the last batch, in every registered store. */
+
+import type { RegisteredMigrationSource } from '../migrations/types.js'
+import { MigrateBase } from './MigrateBase.js'
+
+export default class MigrateRollback extends MigrateBase {
+  static override commandName = 'migrate:rollback'
+  static override description = 'Roll back the last batch for every registered migration source'
+
+  protected async migrateSource(source: RegisteredMigrationSource): Promise<void> {
+    const rolled = await source.runner.rollback()
+    if (rolled.length === 0) {
+      this.report(source, 'nothing to rollback.')
+      return
+    }
+    for (const name of rolled) this.report(source, `rolled back: ${name}`)
+  }
+}

package/src/commands/MigrateStatus.ts

@@ -0,0 +1,22 @@
+/** `migrate:status` — what has run and what has not, in every registered store. */
+
+import type { RegisteredMigrationSource } from '../migrations/types.js'
+import { MigrateBase } from './MigrateBase.js'
+
+export default class MigrateStatus extends MigrateBase {
+  static override commandName = 'migrate:status'
+  static override description = 'Show applied and pending migrations for every source'
+
+  protected async migrateSource(source: RegisteredMigrationSource): Promise<void> {
+    const statuses = await source.runner.status()
+    if (statuses.length === 0) {
+      this.report(source, 'no migrations found.')
+      return
+    }
+    for (const node of statuses) {
+      const mark = node.status === 'applied' ? '✓' : '○'
+      const batch = node.batch === undefined ? '' : ` (batch ${node.batch})`
+      this.report(source, `${mark} ${node.name}${batch}`)
+    }
+  }
+}

package/src/commands/ScheduleList.ts

@@ -0,0 +1,66 @@
+/**
+ * `schedule:list` — every registered task, when it next fires, and how its past
+ * runs went.
+ *
+ * The columns are the operator's questions in order: is my task registered at
+ * all, on what schedule, when does it fire next, when did it last fire, and is
+ * it failing. Stats come from the scheduler's own tracker, so a task that has
+ * never run reads as `—` rather than a zero that looks like a result.
+ */
+
+import { BaseCommand } from '../console/BaseCommand.js'
+import type { CommandOptions } from '../console/types.js'
+import { resolveScheduler } from './scheduler_resolver.js'
+
+/** Over-long names and cron expressions are truncated so the table stays a table. */
+function truncate(value: string, width: number): string {
+  return value.length > width ? `${value.slice(0, width - 1)}…` : value
+}
+
+function asDate(ms: number | null): string {
+  return ms === null ? '—' : new Date(ms).toISOString()
+}
+
+export default class ScheduleList extends BaseCommand {
+  static override commandName = 'schedule:list'
+  static override description = 'List every registered scheduled task, its next run and its stats'
+  static override options: CommandOptions = { startApp: true }
+
+  async run(): Promise<void> {
+    const scheduler = await resolveScheduler(this)
+    if (!scheduler) return
+
+    const tasks = scheduler.listTasks()
+    if (tasks.length === 0) {
+      this.logger.info('No scheduled tasks registered.')
+      return
+    }
+
+    this.logger.log(
+      [
+        'NAME'.padEnd(32),
+        'CRON'.padEnd(18),
+        'NEXT RUN'.padEnd(22),
+        'LAST RUN'.padEnd(22),
+        'RUNS'.padStart(6),
+        'ERR'.padStart(5),
+        'AVG(ms)'.padStart(9),
+      ].join(' '),
+    )
+
+    for (const task of tasks) {
+      const stats = scheduler.getStats(task.name)
+      this.logger.log(
+        [
+          truncate(task.name, 32).padEnd(32),
+          truncate(task.cronExpr, 18).padEnd(18),
+          asDate(task.nextRun).padEnd(22),
+          asDate(stats.lastRunMs).padEnd(22),
+          String(stats.runCount).padStart(6),
+          String(stats.errorCount).padStart(5),
+          String(Math.round(stats.avgDurationMs)).padStart(9),
+        ].join(' '),
+      )
+    }
+  }
+}

package/src/commands/ScheduleRun.ts

@@ -0,0 +1,65 @@
+/**
+ * `schedule:run <name>` — run one registered task immediately.
+ *
+ * An admin override: it calls the task body directly, so it bypasses both the
+ * cron schedule and the distributed lock. That is the point — you reach for it
+ * when a task must run now, or to see it fail with your own eyes — and it is
+ * also why the exit codes are distinct: `1` the task failed, `2` no such task,
+ * `3` an invocation of it is already in flight.
+ */
+
+import { BaseCommand } from '../console/BaseCommand.js'
+import { args } from '../console/decorators.js'
+import type { CommandOptions } from '../console/types.js'
+import { resolveScheduler } from './scheduler_resolver.js'
+
+export default class ScheduleRun extends BaseCommand {
+  static override commandName = 'schedule:run'
+  static override description = 'Run a registered scheduled task once, now (bypasses the lock)'
+  static override options: CommandOptions = { startApp: true }
+
+  @args.string({ description: 'Task name, as `schedule:list` prints it' })
+  declare name: string
+
+  async run(): Promise<void> {
+    // Rejected here rather than in the scheduler so the message arrives without
+    // the operator first paying for a boot.
+    if (this.name.trim() === '') {
+      this.logger.error('Task name cannot be empty. Usage: schedule:run <name>')
+      this.exitCode = 1
+      return
+    }
+
+    const scheduler = await resolveScheduler(this)
+    if (!scheduler) return
+
+    const result = await scheduler.runTaskNow(this.name)
+    const duration = Math.round(result.durationMs)
+
+    if (result.outcome === 'unknown') {
+      this.logger.error(
+        `Unknown task: ${this.name}. Run "schedule:list" to see the registered tasks.`,
+      )
+      this.exitCode = 2
+      return
+    }
+
+    if (result.outcome === 'already-running') {
+      this.logger.error(
+        `Task ${this.name} is already running in this process — skipped. Try again once it completes.`,
+      )
+      this.exitCode = 3
+      return
+    }
+
+    if (result.outcome === 'completed') {
+      this.logger.success(`${this.name} completed in ${duration} ms`)
+      return
+    }
+
+    this.logger.error(
+      `${this.name} failed after ${duration} ms: ${result.error?.message || 'unknown error'}`,
+    )
+    this.exitCode = 1
+  }
+}

package/src/commands/index.ts

@@ -0,0 +1,73 @@
+/**
+ * `@c9up/ream/commands` — the commands the framework itself ships.
+ *
+ * The shape AdonisJS uses for `@adonisjs/core/commands`: a module answering
+ * `getMetaData()` then `getCommand()`, so listing a command does not import it.
+ *
+ * The kernel registers this loader on its own rather than waiting for an entry
+ * in `reamrc.commands` — the deviation from AdonisJS, where the starter kit
+ * lists it. These commands were part of the `ream` binary before they were
+ * classes, and an application that upgrades must not silently lose them.
+ */
+
+import type { CommandClass, SerializedCommand } from '../console/types.js'
+
+interface Entry {
+  commandName: string
+  description: string
+  load: () => Promise<{ default: CommandClass }>
+}
+
+const COMMANDS: readonly Entry[] = [
+  // The registry commands first: a data package registers its runner, and
+  // these drive whatever registered — they name no store.
+  {
+    commandName: 'migrate',
+    description: 'Run pending migrations for every registered migration source',
+    load: () => import('./Migrate.js'),
+  },
+  {
+    commandName: 'migrate:rollback',
+    description: 'Roll back the last batch for every registered migration source',
+    load: () => import('./MigrateRollback.js'),
+  },
+  {
+    commandName: 'migrate:status',
+    description: 'Show applied and pending migrations for every source',
+    load: () => import('./MigrateStatus.js'),
+  },
+  {
+    commandName: 'schedule:list',
+    description: 'List every registered scheduled task, its next run and its stats',
+    load: () => import('./ScheduleList.js'),
+  },
+  {
+    commandName: 'schedule:run',
+    description: 'Run a registered scheduled task once, now (bypasses the lock)',
+    load: () => import('./ScheduleRun.js'),
+  },
+]
+
+/** `migrate:status` → `migrate`; a name without a colon has no namespace. */
+function namespaceOf(commandName: string): string | null {
+  const colon = commandName.indexOf(':')
+  return colon === -1 ? null : commandName.slice(0, colon)
+}
+
+export async function getMetaData(): Promise<SerializedCommand[]> {
+  return COMMANDS.map((entry) => ({
+    commandName: entry.commandName,
+    namespace: namespaceOf(entry.commandName),
+    description: entry.description,
+    aliases: [],
+    options: { startApp: true },
+    args: [],
+    flags: [],
+  }))
+}
+
+export async function getCommand(metadata: SerializedCommand): Promise<CommandClass | null> {
+  const entry = COMMANDS.find((command) => command.commandName === metadata.commandName)
+  if (!entry) return null
+  return (await entry.load()).default
+}

package/src/commands/scheduler_resolver.ts

@@ -0,0 +1,23 @@
+/**
+ * Resolve the scheduler for the `schedule:*` commands.
+ *
+ * Shared because the failure is the same one on both, and it is a
+ * configuration mistake rather than a crash: the provider is simply not in the
+ * list, and the message has to say so — a container error mentioning an
+ * unbound `scheduler` binding tells an operator nothing.
+ */
+
+import type { BaseCommand } from '../console/BaseCommand.js'
+import type { Scheduler } from '../scheduler/Scheduler.js'
+
+export async function resolveScheduler(command: BaseCommand): Promise<Scheduler | undefined> {
+  try {
+    return await command.app.container.resolve<Scheduler>('scheduler')
+  } catch {
+    command.logger.error(
+      'No ScheduleProvider is registered. Add ScheduleProvider to the providers list in reamrc.ts.',
+    )
+    command.exitCode = 2
+    return undefined
+  }
+}

package/src/debug.ts

@@ -0,0 +1,25 @@
+/**
+ * Debug channels, off unless `NODE_DEBUG` names them — the shape AdonisJS
+ * uses (`NODE_DEBUG=adonisjs:http`).
+ *
+ *   NODE_DEBUG=ream:http ream serve
+ *   NODE_DEBUG=ream:* ream serve
+ *
+ * These are for the framework's own tracing: which route a request matched,
+ * which middleware ran, what status came back. They are NOT request logging —
+ * a production request log belongs to the app's logger (`ctx.logger`), which
+ * is correlation-scoped and structured. Neither framework prints one by
+ * default, and this is the switch for when you need to see the plumbing.
+ *
+ * `debuglog` returns a no-op when the channel is off, so an inactive probe
+ * costs a call. Guard with `.enabled` anywhere the ARGUMENTS would cost
+ * something to build — the per-request probes below all do.
+ */
+
+import { debuglog } from 'node:util'
+
+/** Routing, middleware and response tracing. AdonisJS `adonisjs:http`. */
+export const debugHttp = debuglog('ream:http')
+
+/** Boot: providers, preloads, container bindings. AdonisJS `adonisjs:core`. */
+export const debugCore = debuglog('ream:core')

package/src/dumper/Dumper.ts

@@ -0,0 +1,164 @@
+/**
+ * Value dumping — AdonisJS's `Dumper`, in shape and in method names.
+ *
+ *   import { dd } from '@c9up/ream/services/dumper'
+ *   dd(user)                     // prints and stops the process
+ *
+ *   import dumper from '@c9up/ream/services/dumper'
+ *   response.send(dumper.dumpToHtml(user, { cspNonce: response.nonce }))
+ *
+ * The rendering is `node:util`'s `inspect`, not a dependency. It already knows
+ * about depth limits, circular references, getters, Maps, Sets and typed
+ * arrays, and it colours for a terminal — which is the whole of the ANSI side.
+ * The HTML side escapes that same output rather than building a second
+ * formatter, so the two can never describe a value differently.
+ */
+
+import { inspect } from 'node:util'
+import { escapeHTML } from '../helpers/string.js'
+
+/** Where a dump was written, so the output can say so. */
+export interface DumpSource {
+  location: string
+  line: number
+}
+
+/** Knobs for the terminal rendering — AdonisJS `ConsoleDumpConfig`. */
+export interface ConsoleDumpConfig {
+  /** How deep to walk before printing `[Object]`. Default 4. */
+  depth?: number
+  /** Colour the output. Default: whether stdout is a TTY. */
+  colors?: boolean
+  /** Show non-enumerable properties. Default false. */
+  showHidden?: boolean
+}
+
+/** Knobs for the HTML rendering — AdonisJS `HTMLDumpConfig`. */
+export interface HTMLDumpConfig {
+  /** How deep to walk. Default 4. */
+  depth?: number
+  /** Show non-enumerable properties. Default false. */
+  showHidden?: boolean
+  /** Style overrides for the emitted `<pre>`, as CSS declarations. */
+  styles?: Record<string, string>
+}
+
+const DEFAULT_STYLES: Record<string, string> = {
+  'background-color': '#0b0b0d',
+  color: '#e6e6e6',
+  padding: '1rem',
+  'border-radius': '6px',
+  'font-family': 'ui-monospace, SFMono-Regular, Menlo, monospace',
+  'font-size': '13px',
+  'line-height': '1.5',
+  'overflow-x': 'auto',
+}
+
+export class Dumper {
+  #html: HTMLDumpConfig = {}
+  #ansi: ConsoleDumpConfig = {}
+
+  /** Configure the HTML rendering. Chainable, as in AdonisJS. */
+  configureHtmlOutput(config: HTMLDumpConfig): this {
+    this.#html = { ...this.#html, ...config }
+    return this
+  }
+
+  /** Configure the terminal rendering. Chainable, as in AdonisJS. */
+  configureAnsiOutput(config: ConsoleDumpConfig): this {
+    this.#ansi = { ...this.#ansi, ...config }
+    return this
+  }
+
+  /**
+   * The `<style>` a page needs before its first HTML dump.
+   *
+   * Takes a CSP nonce because a page that sets a nonce-based policy rejects an
+   * unattributed inline `<style>` — and a dump landing in a page that silently
+   * drops its styling is worse than no dump. `response.nonce` is what to pass.
+   */
+  getHeadElements(cspNonce?: string): string {
+    const nonce = cspNonce ? ` nonce="${escapeHTML(cspNonce)}"` : ''
+    const styles = { ...DEFAULT_STYLES, ...this.#html.styles }
+    const declarations = Object.entries(styles)
+      .map(([property, value]) => `  ${property}: ${value};`)
+      .join('\n')
+    return `<style${nonce}>\n.ream-dump {\n${declarations}\n}\n</style>`
+  }
+
+  /** Render `value` for a terminal. */
+  dumpToAnsi(value: unknown, options?: { title?: string; source?: DumpSource }): string {
+    const body = inspect(value, {
+      depth: this.#ansi.depth ?? 4,
+      colors: this.#ansi.colors ?? process.stdout.isTTY === true,
+      showHidden: this.#ansi.showHidden ?? false,
+      // Long strings and arrays are the reason someone is dumping; truncating
+      // them defeats the call.
+      maxStringLength: null,
+      maxArrayLength: null,
+    })
+    return [header(options), body].filter(Boolean).join('\n')
+  }
+
+  /**
+   * Render `value` as HTML.
+   *
+   * The inspected output is escaped before it reaches the page: a dumped value
+   * is by definition data someone else may control, and a dump is something
+   * you reach for while debugging — exactly when a script tag in a field name
+   * would be least expected.
+   */
+  dumpToHtml(
+    value: unknown,
+    options?: { cspNonce?: string; title?: string; source?: DumpSource },
+  ): string {
+    const body = inspect(value, {
+      depth: this.#html.depth ?? 4,
+      colors: false,
+      showHidden: this.#html.showHidden ?? false,
+      maxStringLength: null,
+      maxArrayLength: null,
+    })
+    const heading = header(options)
+    const label = heading ? `<div class="ream-dump-header">${escapeHTML(heading)}</div>` : ''
+    return `${this.getHeadElements(options?.cspNonce)}\n${label}<pre class="ream-dump">${escapeHTML(body)}</pre>`
+  }
+
+  /**
+   * Dump and die — print to stderr and stop the process.
+   *
+   * `traceSourceIndex` selects which stack frame to report as the dump site:
+   * 1 is the caller of `dd`, which is right when `dd` is called directly, and
+   * a wrapper passes 2.
+   */
+  dd(value: unknown, traceSourceIndex = 1): void {
+    process.stderr.write(`${this.dumpToAnsi(value, { source: callSite(traceSourceIndex) })}\n`)
+    process.exit(1)
+  }
+}
+
+/** `title` and `source` as one line, or nothing when neither is given. */
+function header(options?: { title?: string; source?: DumpSource }): string {
+  const parts: string[] = []
+  if (options?.title) parts.push(options.title)
+  if (options?.source) parts.push(`${options.source.location}:${options.source.line}`)
+  return parts.join(' — ')
+}
+
+/**
+ * Where `dd` was called, read from a thrown stack.
+ *
+ * Best-effort: a bundled or minified frame may not parse, and a dump that
+ * cannot name its own line is still a useful dump — so a miss returns nothing
+ * rather than throwing on the debugging path.
+ */
+function callSite(index: number): DumpSource | undefined {
+  const frames = new Error().stack?.split('\n').slice(1)
+  const frame = frames?.[index]
+  if (!frame) return undefined
+  const match = /\(?(.+):(\d+):\d+\)?$/.exec(frame.trim())
+  const location = match?.[1]
+  const line = match?.[2]
+  if (!location || !line) return undefined
+  return { location, line: Number(line) }
+}

package/src/index.ts

@@ -371,4 +371,4 @@ export {
   StatsTracker,
 } from './scheduler/index.js'
 
-export const VERSION = '0.2.7'
+export const VERSION = '0.2.9'

package/src/middleware/Pipeline.ts

@@ -11,6 +11,7 @@
  * 5. Handler
  */
 
+import { debugHttp } from '../debug.js'
 import { ReamError } from '../errors/ReamError.js'
 import { E_FORBIDDEN, E_UNAUTHORIZED, E_VALIDATION_ERROR } from '../http/Exception.js'
 import type { HttpContext } from '../http/HttpContext.js'
@@ -196,6 +197,12 @@ function composeMiddleware(middleware: MiddlewareFunction[]): MiddlewareFunction
       const fn = i < middleware.length ? middleware[i] : finalNext
       if (!fn) return
 
+      if (debugHttp.enabled && i < middleware.length) {
+        // `fn.name` is what a named middleware function or a bound class
+        // method carries; an inline arrow has none, and its position is the
+        // only thing that identifies it.
+        debugHttp('middleware %d/%d %s', i + 1, middleware.length, fn.name || '(anonymous)')
+      }
       await fn(ctx, () => dispatch(i + 1))
     }
 

package/src/repl/Repl.ts

@@ -0,0 +1,162 @@
+/**
+ * The application REPL — AdonisJS's `Repl`, in shape and in method names.
+ *
+ *   import repl from '@c9up/ream/services/repl'
+ *   repl.addMethod('loadModels', async () => { … }, {
+ *     description: 'Load every entity onto the prompt',
+ *   })
+ *   repl.start({ app, router })
+ *
+ * Built on `node:repl`, which is the REPL — this adds what makes it an
+ * APPLICATION repl: a context seeded with the booted services, helpers a
+ * project registers itself, and `.ls` to list them, because a prompt full of
+ * undiscoverable helpers is a prompt nobody uses.
+ */
+
+import type { REPLServer } from 'node:repl'
+import { start as startNodeRepl } from 'node:repl'
+
+/** What a registered helper receives — the repl itself, then its arguments. */
+export type MethodCallback = (repl: Repl, ...args: unknown[]) => unknown
+
+/** How a helper describes itself in `.ls`. */
+export interface MethodOptions {
+  description?: string
+  usage?: string
+}
+
+/**
+ * A TypeScript compiler for the prompt, when the host has one.
+ *
+ * `node:repl` evaluates JavaScript. A project whose code is TypeScript wants
+ * to paste TypeScript, so the host supplies the compiler it already runs
+ * rather than ream carrying one.
+ */
+export interface Compiler {
+  compile(code: string, fileName: string): string
+  supportsTypescript: boolean
+}
+
+interface RegisteredMethod {
+  handler: MethodCallback
+  options: MethodOptions & { width: number }
+}
+
+export class Repl {
+  readonly #methods = new Map<string, RegisteredMethod>()
+  readonly #readyCallbacks: Array<(repl: Repl) => void> = []
+  #compiler: Compiler | undefined
+  #server: REPLServer | undefined
+  readonly #prompt: string
+  readonly #write: (message: string) => void
+
+  constructor(options: { prompt?: string; write?: (message: string) => void } = {}) {
+    this.#prompt = options.prompt ?? '> '
+    this.#write =
+      options.write ??
+      ((message) => {
+        process.stdout.write(message)
+      })
+  }
+
+  /**
+   * Print a message around the prompt.
+   *
+   * Newline-wrapped: written mid-session the text would otherwise land on the
+   * line the user is typing.
+   */
+  notify(message: string): void {
+    this.#write(`\n${message}\n`)
+  }
+
+  /** Run `callback` once the prompt is up. Chainable. */
+  ready(callback: (repl: Repl) => void): this {
+    this.#readyCallbacks.push(callback)
+    return this
+  }
+
+  /**
+   * Register a helper, available at the prompt by name. Chainable.
+   *
+   * `width` is the name's display width, recorded here so `.ls` can align a
+   * column without measuring the set twice.
+   */
+  addMethod(name: string, handler: MethodCallback, options: MethodOptions = {}): this {
+    this.#methods.set(name, { handler, options: { ...options, width: name.length } })
+    return this
+  }
+
+  /** Every registered helper, keyed by name — AdonisJS `getMethods`. */
+  getMethods(): Record<string, RegisteredMethod> {
+    return Object.fromEntries(this.#methods)
+  }
+
+  /** Use `compiler` for the code typed at the prompt. Chainable. */
+  useCompiler(compiler: Compiler): this {
+    this.#compiler = compiler
+    return this
+  }
+
+  /** The compiler in use, if any. */
+  get compiler(): Compiler | undefined {
+    return this.#compiler
+  }
+
+  /** The underlying `node:repl` server, once started. */
+  get server(): REPLServer | undefined {
+    return this.#server
+  }
+
+  /**
+   * List the registered helpers, one per line, names aligned.
+   *
+   * Exposed rather than private because it IS the `.ls` command, and a caller
+   * driving the repl programmatically (a test, a custom command) needs the
+   * same listing without a live prompt.
+   */
+  describeMethods(): string {
+    if (this.#methods.size === 0) return 'No methods registered'
+    const widest = Math.max(...[...this.#methods.values()].map((m) => m.options.width))
+    return [...this.#methods]
+      .map(([name, method]) => {
+        const description = method.options.description ?? ''
+        const usage = method.options.usage ? ` (${method.options.usage})` : ''
+        return `${name.padEnd(widest)}  ${description}${usage}`.trimEnd()
+      })
+      .join('\n')
+  }
+
+  /**
+   * Start the prompt, seeding it with `context`.
+   *
+   * Registered helpers are bound to this repl before the prompt appears — a
+   * helper that only exists after the first keystroke is a helper the user
+   * finds missing.
+   */
+  start(context: Record<string, unknown> = {}): this {
+    const server = startNodeRepl({ prompt: this.#prompt, useGlobal: false })
+    this.#server = server
+
+    for (const [key, value] of Object.entries(context)) {
+      Object.defineProperty(server.context, key, { value, configurable: true, enumerable: true })
+    }
+    for (const [name, method] of this.#methods) {
+      Object.defineProperty(server.context, name, {
+        value: (...args: unknown[]) => method.handler(this, ...args),
+        configurable: true,
+        enumerable: true,
+      })
+    }
+
+    server.defineCommand('ls', {
+      help: 'List the helpers available at this prompt',
+      action: () => {
+        this.notify(this.describeMethods())
+        server.displayPrompt()
+      },
+    })
+
+    for (const callback of this.#readyCallbacks) callback(this)
+    return this
+  }
+}

package/src/services/dumper.ts

@@ -0,0 +1,30 @@
+/**
+ * Dumper singleton service.
+ *
+ *   import { dd } from '@c9up/ream/services/dumper'
+ *   dd(user)
+ *
+ *   import dumper from '@c9up/ream/services/dumper'
+ *   dumper.configureAnsiOutput({ depth: 8 })
+ *
+ * Unlike the other accessors this one holds a real instance rather than a
+ * proxy: the dumper depends on nothing the boot phase builds, and something
+ * you reach for mid-debug should not require a booted application.
+ */
+
+import { Dumper } from '../dumper/Dumper.js'
+
+const dumper = new Dumper()
+
+/**
+ * Dump and die — AdonisJS's `dd`.
+ *
+ * The trace index is 2, not the default 1: the frame above is this function,
+ * so the caller of `dd` is one further out. Without it, every dump would
+ * report this file as its source.
+ */
+export const dd = (value: unknown): void => {
+  dumper.dd(value, 2)
+}
+
+export default dumper