@hasna/logs 0.1.0 → 0.3.0

package/dist/server/index.js

@@ -6,7 +6,10 @@ import {
   setPageAuth,
   setRetentionPolicy,
   startScheduler
-} from "../index-4x090f69.js";
+} from "../index-c1rwjhff.js";
+import {
+  countLogs
+} from "../index-n8qd55mt.js";
 import {
   createAlertRule,
   createPage,
@@ -15,7 +18,6 @@ import {
   getDb,
   getIssue,
   getLatestSnapshot,
-  getLogContext,
   getPerfTrend,
   getProject,
   ingestBatch,
@@ -24,19 +26,24 @@ import {
   listIssues,
   listPages,
   listProjects,
-  searchLogs,
+  resolveProjectId,
   summarizeLogs,
-  tailLogs,
   updateAlertRule,
   updateIssueStatus,
   updateProject
-} from "../index-qmsvtxax.js";
+} from "../index-34xx795x.js";
 import {
   createJob,
   deleteJob,
   listJobs,
   updateJob
 } from "../jobs-124e878j.js";
+import {
+  getLogContext,
+  parseTime,
+  searchLogs,
+  tailLogs
+} from "../query-d5b0chp4.js";
 import {
   exportToCsv,
   exportToJson
@@ -1669,6 +1676,277 @@ var cors = (options) => {
   };
 };
 
+// node_modules/hono/dist/adapter/bun/serve-static.js
+import { stat } from "fs/promises";
+import { join } from "path";
+
+// node_modules/hono/dist/utils/compress.js
+var COMPRESSIBLE_CONTENT_TYPE_REGEX = /^\s*(?:text\/(?!event-stream(?:[;\s]|$))[^;\s]+|application\/(?:javascript|json|xml|xml-dtd|ecmascript|dart|postscript|rtf|tar|toml|vnd\.dart|vnd\.ms-fontobject|vnd\.ms-opentype|wasm|x-httpd-php|x-javascript|x-ns-proxy-autoconfig|x-sh|x-tar|x-virtualbox-hdd|x-virtualbox-ova|x-virtualbox-ovf|x-virtualbox-vbox|x-virtualbox-vdi|x-virtualbox-vhd|x-virtualbox-vmdk|x-www-form-urlencoded)|font\/(?:otf|ttf)|image\/(?:bmp|vnd\.adobe\.photoshop|vnd\.microsoft\.icon|vnd\.ms-dds|x-icon|x-ms-bmp)|message\/rfc822|model\/gltf-binary|x-shader\/x-fragment|x-shader\/x-vertex|[^;\s]+?\+(?:json|text|xml|yaml))(?:[;\s]|$)/i;
+
+// node_modules/hono/dist/utils/mime.js
+var getMimeType = (filename, mimes = baseMimes) => {
+  const regexp = /\.([a-zA-Z0-9]+?)$/;
+  const match2 = filename.match(regexp);
+  if (!match2) {
+    return;
+  }
+  let mimeType = mimes[match2[1].toLowerCase()];
+  if (mimeType && mimeType.startsWith("text")) {
+    mimeType += "; charset=utf-8";
+  }
+  return mimeType;
+};
+var _baseMimes = {
+  aac: "audio/aac",
+  avi: "video/x-msvideo",
+  avif: "image/avif",
+  av1: "video/av1",
+  bin: "application/octet-stream",
+  bmp: "image/bmp",
+  css: "text/css",
+  csv: "text/csv",
+  eot: "application/vnd.ms-fontobject",
+  epub: "application/epub+zip",
+  gif: "image/gif",
+  gz: "application/gzip",
+  htm: "text/html",
+  html: "text/html",
+  ico: "image/x-icon",
+  ics: "text/calendar",
+  jpeg: "image/jpeg",
+  jpg: "image/jpeg",
+  js: "text/javascript",
+  json: "application/json",
+  jsonld: "application/ld+json",
+  map: "application/json",
+  mid: "audio/x-midi",
+  midi: "audio/x-midi",
+  mjs: "text/javascript",
+  mp3: "audio/mpeg",
+  mp4: "video/mp4",
+  mpeg: "video/mpeg",
+  oga: "audio/ogg",
+  ogv: "video/ogg",
+  ogx: "application/ogg",
+  opus: "audio/opus",
+  otf: "font/otf",
+  pdf: "application/pdf",
+  png: "image/png",
+  rtf: "application/rtf",
+  svg: "image/svg+xml",
+  tif: "image/tiff",
+  tiff: "image/tiff",
+  ts: "video/mp2t",
+  ttf: "font/ttf",
+  txt: "text/plain",
+  wasm: "application/wasm",
+  webm: "video/webm",
+  weba: "audio/webm",
+  webmanifest: "application/manifest+json",
+  webp: "image/webp",
+  woff: "font/woff",
+  woff2: "font/woff2",
+  xhtml: "application/xhtml+xml",
+  xml: "application/xml",
+  zip: "application/zip",
+  "3gp": "video/3gpp",
+  "3g2": "video/3gpp2",
+  gltf: "model/gltf+json",
+  glb: "model/gltf-binary"
+};
+var baseMimes = _baseMimes;
+
+// node_modules/hono/dist/middleware/serve-static/path.js
+var defaultJoin = (...paths) => {
+  let result = paths.filter((p) => p !== "").join("/");
+  result = result.replace(/(?<=\/)\/+/g, "");
+  const segments = result.split("/");
+  const resolved = [];
+  for (const segment of segments) {
+    if (segment === ".." && resolved.length > 0 && resolved.at(-1) !== "..") {
+      resolved.pop();
+    } else if (segment !== ".") {
+      resolved.push(segment);
+    }
+  }
+  return resolved.join("/") || ".";
+};
+
+// node_modules/hono/dist/middleware/serve-static/index.js
+var ENCODINGS = {
+  br: ".br",
+  zstd: ".zst",
+  gzip: ".gz"
+};
+var ENCODINGS_ORDERED_KEYS = Object.keys(ENCODINGS);
+var DEFAULT_DOCUMENT = "index.html";
+var serveStatic = (options) => {
+  const root = options.root ?? "./";
+  const optionPath = options.path;
+  const join = options.join ?? defaultJoin;
+  return async (c, next) => {
+    if (c.finalized) {
+      return next();
+    }
+    let filename;
+    if (options.path) {
+      filename = options.path;
+    } else {
+      try {
+        filename = tryDecodeURI(c.req.path);
+        if (/(?:^|[\/\\])\.\.(?:$|[\/\\])/.test(filename)) {
+          throw new Error;
+        }
+      } catch {
+        await options.onNotFound?.(c.req.path, c);
+        return next();
+      }
+    }
+    let path = join(root, !optionPath && options.rewriteRequestPath ? options.rewriteRequestPath(filename) : filename);
+    if (options.isDir && await options.isDir(path)) {
+      path = join(path, DEFAULT_DOCUMENT);
+    }
+    const getContent = options.getContent;
+    let content = await getContent(path, c);
+    if (content instanceof Response) {
+      return c.newResponse(content.body, content);
+    }
+    if (content) {
+      const mimeType = options.mimes && getMimeType(path, options.mimes) || getMimeType(path);
+      c.header("Content-Type", mimeType || "application/octet-stream");
+      if (options.precompressed && (!mimeType || COMPRESSIBLE_CONTENT_TYPE_REGEX.test(mimeType))) {
+        const acceptEncodingSet = new Set(c.req.header("Accept-Encoding")?.split(",").map((encoding) => encoding.trim()));
+        for (const encoding of ENCODINGS_ORDERED_KEYS) {
+          if (!acceptEncodingSet.has(encoding)) {
+            continue;
+          }
+          const compressedContent = await getContent(path + ENCODINGS[encoding], c);
+          if (compressedContent) {
+            content = compressedContent;
+            c.header("Content-Encoding", encoding);
+            c.header("Vary", "Accept-Encoding", { append: true });
+            break;
+          }
+        }
+      }
+      await options.onFound?.(path, c);
+      return c.body(content);
+    }
+    await options.onNotFound?.(path, c);
+    await next();
+    return;
+  };
+};
+
+// node_modules/hono/dist/adapter/bun/serve-static.js
+var serveStatic2 = (options) => {
+  return async function serveStatic2(c, next) {
+    const getContent = async (path) => {
+      const file = Bun.file(path);
+      return await file.exists() ? file : null;
+    };
+    const isDir = async (path) => {
+      let isDir2;
+      try {
+        const stats = await stat(path);
+        isDir2 = stats.isDirectory();
+      } catch {}
+      return isDir2;
+    };
+    return serveStatic({
+      ...options,
+      getContent,
+      join,
+      isDir
+    })(c, next);
+  };
+};
+
+// node_modules/hono/dist/helper/ssg/middleware.js
+var X_HONO_DISABLE_SSG_HEADER_KEY = "x-hono-disable-ssg";
+var SSG_DISABLED_RESPONSE = (() => {
+  try {
+    return new Response("SSG is disabled", {
+      status: 404,
+      headers: { [X_HONO_DISABLE_SSG_HEADER_KEY]: "true" }
+    });
+  } catch {
+    return null;
+  }
+})();
+// node_modules/hono/dist/adapter/bun/ssg.js
+var { write } = Bun;
+
+// node_modules/hono/dist/helper/websocket/index.js
+var WSContext = class {
+  #init;
+  constructor(init) {
+    this.#init = init;
+    this.raw = init.raw;
+    this.url = init.url ? new URL(init.url) : null;
+    this.protocol = init.protocol ?? null;
+  }
+  send(source, options) {
+    this.#init.send(source, options ?? {});
+  }
+  raw;
+  binaryType = "arraybuffer";
+  get readyState() {
+    return this.#init.readyState;
+  }
+  url;
+  protocol;
+  close(code, reason) {
+    this.#init.close(code, reason);
+  }
+};
+var defineWebSocketHelper = (handler) => {
+  return (...args) => {
+    if (typeof args[0] === "function") {
+      const [createEvents, options] = args;
+      return async function upgradeWebSocket(c, next) {
+        const events = await createEvents(c);
+        const result = await handler(c, events, options);
+        if (result) {
+          return result;
+        }
+        await next();
+      };
+    } else {
+      const [c, events, options] = args;
+      return (async () => {
+        const upgraded = await handler(c, events, options);
+        if (!upgraded) {
+          throw new Error("Failed to upgrade WebSocket");
+        }
+        return upgraded;
+      })();
+    }
+  };
+};
+
+// node_modules/hono/dist/adapter/bun/server.js
+var getBunServer = (c) => ("server" in c.env) ? c.env.server : c.env;
+
+// node_modules/hono/dist/adapter/bun/websocket.js
+var upgradeWebSocket = defineWebSocketHelper((c, events) => {
+  const server = getBunServer(c);
+  if (!server) {
+    throw new TypeError("env has to include the 2nd argument of fetch.");
+  }
+  const upgradeResult = server.upgrade(c.req.raw, {
+    data: {
+      events,
+      url: new URL(c.req.url),
+      protocol: c.req.url
+    }
+  });
+  if (upgradeResult) {
+    return new Response(null);
+  }
+  return;
+});
+
 // src/lib/browser-script.ts
 function getBrowserScript(serverUrl) {
   return `(function(){
@@ -1824,9 +2102,29 @@ function logsRoutes(db) {
   });
   app.get("/summary", (c) => {
     const { project_id, since } = c.req.query();
-    const summary = summarizeLogs(db, project_id || undefined, since || undefined);
+    const summary = summarizeLogs(db, resolveProjectId(db, project_id) || undefined, parseTime(since) || since || undefined);
     return c.json(summary);
   });
+  app.get("/count", (c) => {
+    const { project_id, service, level, since, until } = c.req.query();
+    return c.json(countLogs(db, {
+      project_id: resolveProjectId(db, project_id) || undefined,
+      service: service || undefined,
+      level: level || undefined,
+      since: since || undefined,
+      until: until || undefined
+    }));
+  });
+  app.get("/recent-errors", (c) => {
+    const { project_id, since, limit } = c.req.query();
+    const rows = searchLogs(db, {
+      project_id: resolveProjectId(db, project_id) || undefined,
+      level: ["error", "fatal"],
+      since: parseTime(since || "1h"),
+      limit: limit ? Number(limit) : 20
+    });
+    return c.json(rows.map((r) => ({ id: r.id, timestamp: r.timestamp, level: r.level, message: r.message, service: r.service, age_seconds: Math.floor((Date.now() - new Date(r.timestamp).getTime()) / 1000) })));
+  });
   app.get("/:trace_id/context", (c) => {
     const rows = getLogContext(db, c.req.param("trace_id"));
     return c.json(rows);
@@ -2160,7 +2458,9 @@ app.route("/api/alerts", alertsRoutes(db));
 app.route("/api/issues", issuesRoutes(db));
 app.route("/api/perf", perfRoutes(db));
 app.get("/health", (c) => c.json(getHealth(db)));
-app.get("/", (c) => c.json({ service: "@hasna/logs", port: PORT, status: "ok" }));
+app.get("/dashboard", (c) => c.redirect("/dashboard/"));
+app.use("/dashboard/*", serveStatic2({ root: "./dashboard/dist", rewriteRequestPath: (p) => p.replace(/^\/dashboard/, "") }));
+app.get("/", (c) => c.json({ service: "@hasna/logs", port: PORT, status: "ok", dashboard: `http://localhost:${PORT}/dashboard/` }));
 startScheduler(db);
 console.log(`@hasna/logs server running on http://localhost:${PORT}`);
 var server_default = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/logs",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Log aggregation + browser script + headless page scanner + performance monitoring for AI agents",
   "type": "module",
   "main": "./dist/index.js",
@@ -12,6 +12,8 @@
   },
   "scripts": {
     "build": "bun build src/cli/index.ts src/mcp/index.ts src/server/index.ts --outdir dist --target bun --splitting --external playwright --external playwright-core --external electron --external chromium-bidi --external lighthouse",
+    "build:dashboard": "cd dashboard && bun run build",
+    "build:all": "bun run build:dashboard && bun run build",
     "dev": "bun run src/server/index.ts",
     "test": "bun test",
     "test:coverage": "bun test --coverage",

package/sdk/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hasna/logs-sdk",
-  "version": "0.0.1",
-  "description": "Zero-dependency fetch client for @hasna/logs",
+  "version": "0.1.0",
+  "description": "Zero-dependency fetch client for @hasna/logs — push logs, query, browse issues, perf snapshots",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -16,6 +16,7 @@
   "scripts": {
     "build": "bun build src/index.ts --outdir dist --target browser"
   },
+  "keywords": ["logs", "monitoring", "sdk", "ai-agents"],
   "author": "Andrei Hasna <andrei@hasna.com>",
   "license": "MIT"
 }

package/sdk/src/index.ts

@@ -1,4 +1,4 @@
-import type { LogEntry, LogLevel, LogQuery, LogRow, LogSummary, Page, PerformanceSnapshot, Project, ScanJob } from "../../src/types/index.ts"
+import type { LogEntry, LogLevel, LogQuery, LogRow, LogSummary, Page, PerformanceSnapshot, Project, ScanJob } from "./types.ts"
 
 export type { LogEntry, LogLevel, LogQuery, LogRow, LogSummary, Page, PerformanceSnapshot, Project, ScanJob }
 

package/sdk/src/types.ts

@@ -0,0 +1,56 @@
+export type LogLevel = "debug" | "info" | "warn" | "error" | "fatal"
+export type LogSource = "sdk" | "script" | "scanner"
+
+export interface LogEntry {
+  level: LogLevel
+  message: string
+  project_id?: string
+  page_id?: string
+  source?: LogSource
+  service?: string
+  trace_id?: string
+  session_id?: string
+  agent?: string
+  url?: string
+  stack_trace?: string
+  metadata?: Record<string, unknown>
+}
+
+export interface LogRow {
+  id: string; timestamp: string; project_id: string | null; page_id: string | null
+  level: LogLevel; source: LogSource; service: string | null; message: string
+  trace_id: string | null; session_id: string | null; agent: string | null
+  url: string | null; stack_trace: string | null; metadata: string | null
+}
+
+export interface Project {
+  id: string; name: string; github_repo: string | null; base_url: string | null
+  description: string | null; created_at: string
+}
+
+export interface Page {
+  id: string; project_id: string; url: string; path: string
+  name: string | null; last_scanned_at: string | null; created_at: string
+}
+
+export interface ScanJob {
+  id: string; project_id: string; page_id: string | null
+  schedule: string; enabled: number; last_run_at: string | null; created_at: string
+}
+
+export interface PerformanceSnapshot {
+  id: string; timestamp: string; project_id: string; page_id: string | null
+  url: string; lcp: number | null; fcp: number | null; cls: number | null
+  tti: number | null; ttfb: number | null; score: number | null; raw_audit: string | null
+}
+
+export interface LogQuery {
+  project_id?: string; page_id?: string; level?: LogLevel | LogLevel[]
+  service?: string; since?: string; until?: string; text?: string
+  trace_id?: string; limit?: number; offset?: number; fields?: string[]
+}
+
+export interface LogSummary {
+  project_id: string | null; service: string | null; page_id: string | null
+  level: LogLevel; count: number; latest: string
+}

package/src/cli/index.ts

@@ -151,6 +151,58 @@ program.command("scan")
     console.log("Scan complete.")
   })
 
+// ── logs watch ────────────────────────────────────────────
+program.command("watch")
+  .description("Stream new logs in real time with color coding")
+  .option("--project <id>")
+  .option("--level <levels>", "Comma-separated levels")
+  .option("--service <name>")
+  .action(async (opts) => {
+    const db = getDb()
+    const { searchLogs } = await import("../lib/query.ts")
+
+    const COLORS: Record<string, string> = {
+      debug: "\x1b[90m", info: "\x1b[36m", warn: "\x1b[33m", error: "\x1b[31m", fatal: "\x1b[35m",
+    }
+    const RESET = "\x1b[0m"
+    const BOLD = "\x1b[1m"
+
+    let lastTimestamp = new Date().toISOString()
+    let errorCount = 0
+    let warnCount = 0
+
+    process.stdout.write(`\x1b[2J\x1b[H`) // clear screen
+    console.log(`${BOLD}@hasna/logs watch${RESET} — Ctrl+C to exit\n`)
+
+    const poll = () => {
+      const rows = searchLogs(db, {
+        project_id: opts.project,
+        level: opts.level ? (opts.level.split(",") as LogLevel[]) : undefined,
+        service: opts.service,
+        since: lastTimestamp,
+        limit: 100,
+      }).reverse()
+
+      for (const row of rows) {
+        if (row.timestamp <= lastTimestamp) continue
+        lastTimestamp = row.timestamp
+        if (row.level === "error" || row.level === "fatal") errorCount++
+        if (row.level === "warn") warnCount++
+        const color = COLORS[row.level] ?? ""
+        const ts = row.timestamp.slice(11, 19)
+        const svc = (row.service ?? "-").padEnd(12)
+        const lvl = row.level.toUpperCase().padEnd(5)
+        console.log(`${color}${ts}  ${BOLD}${lvl}${RESET}${color}  ${svc}  ${row.message}${RESET}`)
+      }
+
+      // Update terminal title with counts
+      process.stdout.write(`\x1b]2;logs: ${errorCount}E ${warnCount}W\x07`)
+    }
+
+    const interval = setInterval(poll, 500)
+    process.on("SIGINT", () => { clearInterval(interval); console.log(`\n\nErrors: ${errorCount}  Warnings: ${warnCount}`); process.exit(0) })
+  })
+
 // ── logs export ───────────────────────────────────────────
 program.command("export")
   .description("Export logs to JSON or CSV")
@@ -203,11 +255,25 @@ program.command("mcp")
   .option("--gemini", "Install into Gemini")
   .action(async (opts) => {
     if (opts.claude || opts.codex || opts.gemini) {
-      const bin = process.execPath
-      const script = new URL(import.meta.url).pathname
+      const { execSync } = await import("node:child_process")
+      // Resolve the MCP binary path — works from both source and dist
+      const selfPath = process.argv[1] ?? new URL(import.meta.url).pathname
+      const mcpBin = selfPath.replace(/cli\/index\.(ts|js)$/, "mcp/index.$1")
+      const runtime = process.execPath  // bun or node
+
       if (opts.claude) {
-        const { execSync } = await import("node:child_process")
-        execSync(`claude mcp add --transport stdio --scope user logs -- ${bin} ${script} mcp`, { stdio: "inherit" })
+        const cmd = `claude mcp add --transport stdio --scope user logs -- ${runtime} ${mcpBin}`
+        console.log(`Running: ${cmd}`)
+        execSync(cmd, { stdio: "inherit" })
+        console.log("✓ Installed logs-mcp into Claude Code")
+      }
+      if (opts.codex) {
+        const config = `[mcp_servers.logs]\ncommand = "${runtime}"\nargs = ["${mcpBin}"]`
+        console.log("Add to ~/.codex/config.toml:\n\n" + config)
+      }
+      if (opts.gemini) {
+        const config = JSON.stringify({ mcpServers: { logs: { command: runtime, args: [mcpBin] } } }, null, 2)
+        console.log("Add to ~/.gemini/settings.json mcpServers:\n\n" + config)
       }
       return
     }

package/src/lib/count.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, it } from "bun:test"
+import { createTestDb } from "../db/index.ts"
+import { ingestBatch } from "./ingest.ts"
+import { countLogs } from "./count.ts"
+
+describe("countLogs", () => {
+  it("counts all logs", () => {
+    const db = createTestDb()
+    ingestBatch(db, [{ level: "error", message: "e" }, { level: "warn", message: "w" }, { level: "info", message: "i" }])
+    const c = countLogs(db, {})
+    expect(c.total).toBe(3)
+    expect(c.errors).toBe(1)
+    expect(c.warns).toBe(1)
+    expect(c.fatals).toBe(0)
+  })
+
+  it("filters by project", () => {
+    const db = createTestDb()
+    const p = db.prepare("INSERT INTO projects (name) VALUES ('app') RETURNING id").get() as { id: string }
+    ingestBatch(db, [{ level: "error", message: "e", project_id: p.id }, { level: "error", message: "e2" }])
+    const c = countLogs(db, { project_id: p.id })
+    expect(c.total).toBe(1)
+  })
+
+  it("filters by service", () => {
+    const db = createTestDb()
+    ingestBatch(db, [{ level: "error", message: "e", service: "api" }, { level: "error", message: "e2", service: "db" }])
+    expect(countLogs(db, { service: "api" }).total).toBe(1)
+  })
+
+  it("returns zero counts for empty db", () => {
+    const c = countLogs(createTestDb(), {})
+    expect(c.total).toBe(0)
+    expect(c.errors).toBe(0)
+    expect(c.by_level).toEqual({})
+  })
+
+  it("accepts relative since", () => {
+    const db = createTestDb()
+    ingestBatch(db, [{ level: "error", message: "recent" }])
+    const c = countLogs(db, { since: "1h" })
+    expect(c.total).toBe(1)
+  })
+})

package/src/lib/count.ts

@@ -0,0 +1,45 @@
+import type { Database } from "bun:sqlite"
+import { parseTime } from "./parse-time.ts"
+
+export interface LogCount {
+  total: number
+  errors: number
+  warns: number
+  fatals: number
+  by_level: Record<string, number>
+}
+
+export function countLogs(db: Database, opts: {
+  project_id?: string
+  service?: string
+  level?: string
+  since?: string
+  until?: string
+}): LogCount {
+  const conditions: string[] = []
+  const params: Record<string, unknown> = {}
+
+  if (opts.project_id) { conditions.push("project_id = $p"); params.$p = opts.project_id }
+  if (opts.service) { conditions.push("service = $service"); params.$service = opts.service }
+  if (opts.level) { conditions.push("level = $level"); params.$level = opts.level }
+  const since = parseTime(opts.since)
+  const until = parseTime(opts.until)
+  if (since) { conditions.push("timestamp >= $since"); params.$since = since }
+  if (until) { conditions.push("timestamp <= $until"); params.$until = until }
+
+  const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : ""
+
+  const byLevel = db.prepare(`SELECT level, COUNT(*) as c FROM logs ${where} GROUP BY level`)
+    .all(params) as { level: string; c: number }[]
+
+  const by_level = Object.fromEntries(byLevel.map(r => [r.level, r.c]))
+  const total = byLevel.reduce((s, r) => s + r.c, 0)
+
+  return {
+    total,
+    errors: by_level["error"] ?? 0,
+    warns: by_level["warn"] ?? 0,
+    fatals: by_level["fatal"] ?? 0,
+    by_level,
+  }
+}