nilometer 0.0.0-stage → 0.2.0

package/core/schema/031_cte_cursor_budget.sql

@@ -0,0 +1,153 @@
+-- 031_cte_cursor_budget: the lockout views read each costly view once, so they prepare on SQLite 3.54 (D-094, step G5.2).
+--
+-- SQLite 3.54.0 refuses a statement once a CTE's cursor number passes SQLITE_LIMIT_EXPR_DEPTH (1,000), with
+-- "VIEWs and/or subqueries nested too deep". Every reference to a view expands it again, cursors and all, so a
+-- view read four times costs four times its cursors. obs_lockout_intervals read the lockout hits four times
+-- (593 by that measure), and obs_lockout_time and obs_interruptions_by_plan read it twice more: over the limit.
+-- Node 26 bundles 3.54.0. Same rows, same columns, same order; only how often each view is read changes.
+
+DROP VIEW obs_lockout_intervals;
+
+-- Observed: elapsed lockout intervals (limit hit to reset, overlapping hits merged), with the next request after each reset, logged auto-continuations, and the sessions and refused requests in each (D-023, D-077, D-090).
+CREATE VIEW obs_lockout_intervals AS
+WITH continuation_counts AS (
+  -- Logged auto-continuations per limit hit, counted before the join so a hit stays one row.
+  SELECT hit_raw_line_id, COUNT(*) AS marks, MIN(continued_at_utc) AS first_continued_at_utc
+  FROM auto_continuation_marks
+  WHERE hit_raw_line_id IS NOT NULL
+  GROUP BY hit_raw_line_id
+),
+grouped AS (
+  -- One pass over the lockout hits: each is one row (its raw line), and every join below is one-to-one.
+  SELECT
+    h.interval_number,
+    MIN(h.start_utc) AS locked_from_utc,
+    MAX(h.end_utc) AS locked_until_utc,
+    COUNT(*) AS hits,
+    -- A logged hit names its session; a status-line-only hit is a spool reading, which names one too.
+    COUNT(DISTINCT COALESCE(p.session_id, s.session_id)) AS sessions,
+    -- Hits from the session logs: each is a request the limit refused.
+    COUNT(p.raw_line_id) AS refused_requests,
+    SUM(m.marks) AS auto_continuations,
+    MIN(m.first_continued_at_utc) AS first_continued_at_utc
+  FROM obs_lockout_interval_hits h
+  LEFT JOIN parsed_lines p ON p.raw_line_id = h.raw_line_id
+  LEFT JOIN status_readings s ON s.raw_line_id = h.raw_line_id
+  LEFT JOIN continuation_counts m ON m.hit_raw_line_id = h.raw_line_id
+  GROUP BY h.interval_number
+),
+with_next AS (
+  SELECT
+    g.*,
+    (SELECT MIN(d.timestamp_utc) FROM requests_dedup d WHERE d.timestamp_utc >= g.locked_until_utc) AS next_request_at_utc
+  FROM grouped g
+)
+SELECT
+  w.interval_number,
+  w.locked_from_utc,
+  w.locked_until_utc,
+  w.hits,
+  w.next_request_at_utc,
+  (round(unixepoch(w.locked_until_utc, 'subsec') * 1000) - round(unixepoch(w.locked_from_utc, 'subsec') * 1000)) / 1000.0 AS lockout_seconds,
+  (round(unixepoch(w.next_request_at_utc, 'subsec') * 1000) - round(unixepoch(w.locked_until_utc, 'subsec') * 1000)) / 1000.0 AS reset_to_next_request_seconds,
+  w.locked_until_utc > (SELECT covers_to FROM source_coverage WHERE source = 'session_logs') AS reset_after_coverage,
+  -- How many sessions Claude Code resumed by itself after this reset, as logged; 0 when none.
+  COALESCE(w.auto_continuations, 0) AS auto_continuations,
+  -- The earliest of those, seconds after the reset; NULL when none. The reset is one time per lockout, so the
+  -- earliest continuation gives the smallest difference.
+  (round(unixepoch(w.first_continued_at_utc, 'subsec') * 1000) - round(unixepoch(w.locked_until_utc, 'subsec') * 1000)) / 1000.0
+    AS first_auto_continuation_seconds,
+  -- Distinct sessions with a hit in this lockout (D-090).
+  w.sessions,
+  -- Its logged hits, each a refused request; the rest of its hits are status line readings at 100% (D-023, D-090).
+  w.refused_requests
+FROM with_next w;
+
+DROP VIEW obs_lockout_time;
+
+-- Observed: total elapsed lockout time (hit → reset, overlaps counted once), beside hits whose reset is unknown.
+CREATE VIEW obs_lockout_time AS
+SELECT
+  COUNT(*) AS intervals,
+  TOTAL(lockout_seconds) AS lockout_seconds,
+  -- Every hit with a known reset is in exactly one interval, so the intervals' hits add up to them.
+  COALESCE(SUM(hits), 0) AS hits_with_known_reset,
+  (SELECT COUNT(*) FROM obs_limit_hits_events WHERE reset_at_utc IS NULL OR hit_at_utc IS NULL) AS hits_with_unknown_reset,
+  (SELECT covers_from FROM source_coverage WHERE source = 'session_logs') AS covers_from,
+  (SELECT covers_to FROM source_coverage WHERE source = 'session_logs') AS covers_to
+FROM obs_lockout_intervals;
+
+DROP VIEW obs_interruptions_by_plan;
+
+-- Observed: limit hits, lockouts, and elapsed lockout time per plan period, each with its own span (D-075).
+CREATE VIEW obs_interruptions_by_plan AS
+WITH periods AS (
+  SELECT 'plan' AS period_kind, from_month, until_month, plan_name FROM plan_periods
+  UNION ALL
+  -- Before the first entered plan; with no plan entered, the whole history.
+  SELECT 'none', NULL, (SELECT MIN(from_month) FROM plan_periods), NULL
+  UNION ALL
+  -- Hits with no time: counted, so the rows add up to obs_limit_hits, but in no period.
+  SELECT 'unknown', NULL, NULL, NULL
+),
+-- Materialized: the hit view is among the costliest on real data (D-059), and two CTEs read it.
+hits AS MATERIALIZED (
+  SELECT period_kind, from_month, window, hit_at_utc FROM obs_limit_hits_by_plan_events
+),
+-- Counted per period once, then joined: a subquery per count would read the views once per count (D-094).
+hit_counts AS (
+  SELECT
+    period_kind,
+    from_month,
+    COUNT(*) AS hits,
+    SUM(window = 'five_hour') AS five_hour_hits,
+    SUM(window = 'seven_day') AS seven_day_hits,
+    SUM(window IS NULL) AS unknown_window_hits
+  FROM hits
+  GROUP BY period_kind, from_month
+),
+lock_counts AS (
+  SELECT period_kind, from_month, COUNT(*) AS lockouts, TOTAL(lockout_seconds) AS lockout_seconds
+  FROM obs_lockout_by_plan_events
+  GROUP BY period_kind, from_month
+),
+-- What a period's span is drawn from: request times and hit times, each with its local month.
+dated AS MATERIALIZED (
+  SELECT timestamp_utc AS at_utc, strftime('%Y-%m', timestamp_utc, 'localtime') AS month
+  FROM requests_dedup WHERE timestamp_utc IS NOT NULL
+  UNION ALL
+  SELECT hit_at_utc, strftime('%Y-%m', hit_at_utc, 'localtime') FROM hits WHERE hit_at_utc IS NOT NULL
+),
+counted AS (
+  SELECT
+    p.period_kind,
+    p.from_month,
+    -- The last month the plan applies, for display: the month before until_month.
+    CASE WHEN p.until_month IS NOT NULL
+      THEN strftime('%Y-%m', p.until_month || '-01', '-1 month') END AS to_month,
+    p.until_month,
+    p.plan_name,
+    COALESCE(hc.hits, 0) AS hits,
+    COALESCE(hc.five_hour_hits, 0) AS five_hour_hits,
+    COALESCE(hc.seven_day_hits, 0) AS seven_day_hits,
+    COALESCE(hc.unknown_window_hits, 0) AS unknown_window_hits,
+    COALESCE(lc.lockouts, 0) AS lockouts,
+    -- TOTAL, as obs_lockout_time totals intervals: 0 over none.
+    COALESCE(lc.lockout_seconds, 0.0) AS lockout_seconds,
+    -- The span the period's data covers, from what is in it (principle 5); none for 'unknown'.
+    (SELECT MIN(d.at_utc) FROM dated d WHERE p.period_kind <> 'unknown'
+       AND (p.from_month IS NULL OR d.month >= p.from_month)
+       AND (p.until_month IS NULL OR d.month < p.until_month)) AS covers_from,
+    (SELECT MAX(d.at_utc) FROM dated d WHERE p.period_kind <> 'unknown'
+       AND (p.from_month IS NULL OR d.month >= p.from_month)
+       AND (p.until_month IS NULL OR d.month < p.until_month)) AS covers_to
+  FROM periods p
+  -- IS, not =: the 'none' and 'unknown' periods have no month, and NULL = NULL is never true.
+  LEFT JOIN hit_counts hc ON hc.period_kind = p.period_kind AND hc.from_month IS p.from_month
+  LEFT JOIN lock_counts lc ON lc.period_kind = p.period_kind AND lc.from_month IS p.from_month
+)
+SELECT *
+FROM counted
+-- A period appears when it holds a hit or any dated data; an entry for a month with no data, or
+-- a plan entered for the future, has nothing to report.
+WHERE hits > 0 OR covers_from IS NOT NULL;

package/core/schema/032_stored_views.sql

@@ -0,0 +1,233 @@
+-- 032_stored_views: requests_dedup and window_readings become tables that ingest fills from their views (D-096, step G6.1).
+--
+-- Every report statement recomputed both from the raw tables: window_readings pairs each of tens of thousands of
+-- rate-limit readings with its API response through correlated lookups, and requests_dedup ranks every request line.
+-- On real data the report and page ran about 20 statements built on them and took 45-50 s. Their inputs (requests,
+-- parsed_lines, raw_lines, source_files, status_readings, rate_limit_windows) are written only by ingest, so ingest
+-- stores their rows once (core/ingest/stored-views.ts) and everything downstream reads the stored rows. The
+-- definitions are unchanged and keep running as views under *_computed, so the rows trace back exactly as before,
+-- and a test fails if a stored table ever differs from its view.
+--
+-- Columns are ANY in a STRICT table: no type affinity, so every value is stored exactly as the view returned it.
+
+DROP VIEW requests_dedup;
+
+-- Observed: one row per distinct API response (winners) plus every unkeyed request line, as 019 computed it; ingest stores its rows in requests_dedup (D-096).
+CREATE VIEW requests_dedup_computed AS
+WITH ranked AS (
+  SELECT
+    r.raw_line_id,
+    r.dedup_key,
+    r.message_id,
+    r.request_id,
+    r.model,
+    r.input_tokens,
+    r.output_tokens,
+    r.cache_read_tokens,
+    r.cache_write_5m_tokens,
+    r.cache_write_1h_tokens,
+    r.cache_write_unsplit_tokens,
+    r.speed,
+    p.session_id,
+    p.timestamp_raw,
+    p.timestamp_utc,
+    p.cwd,
+    p.is_sidechain,
+    f.root,
+    f.relative_path,
+    l.first_run_id,
+    l.line_number,
+    ROW_NUMBER() OVER (
+      PARTITION BY r.dedup_key
+      ORDER BY r.output_tokens DESC, p.is_sidechain ASC,
+               -- Among lines tied on output, the earliest: when those numbers first existed
+               -- (D-065, the same rule D-045 applies to readings). NULLs last, so an unparsed
+               -- timestamp never wins.
+               (p.timestamp_utc IS NULL) ASC, p.timestamp_utc ASC,
+               f.root DESC, f.relative_path DESC, l.first_run_id DESC, l.line_number DESC
+    ) AS candidate_rank
+  FROM requests r
+  JOIN parsed_lines p ON p.raw_line_id = r.raw_line_id
+  JOIN raw_lines l ON l.id = r.raw_line_id
+  JOIN source_files f ON f.id = l.source_file_id
+)
+SELECT
+  raw_line_id, dedup_key, message_id, request_id, model,
+  input_tokens, output_tokens, cache_read_tokens,
+  cache_write_5m_tokens, cache_write_1h_tokens, cache_write_unsplit_tokens, speed,
+  session_id, timestamp_raw, timestamp_utc, cwd, is_sidechain,
+  root, relative_path, first_run_id, line_number
+FROM ranked
+WHERE dedup_key IS NULL OR candidate_rank = 1;
+
+CREATE TABLE requests_dedup (
+  raw_line_id                ANY, -- derived: requests_dedup_computed.raw_line_id
+  dedup_key                  ANY, -- derived: requests_dedup_computed.dedup_key
+  message_id                 ANY, -- derived: requests_dedup_computed.message_id
+  request_id                 ANY, -- derived: requests_dedup_computed.request_id
+  model                      ANY, -- derived: requests_dedup_computed.model
+  input_tokens               ANY, -- derived: requests_dedup_computed.input_tokens
+  output_tokens              ANY, -- derived: requests_dedup_computed.output_tokens
+  cache_read_tokens          ANY, -- derived: requests_dedup_computed.cache_read_tokens
+  cache_write_5m_tokens      ANY, -- derived: requests_dedup_computed.cache_write_5m_tokens
+  cache_write_1h_tokens      ANY, -- derived: requests_dedup_computed.cache_write_1h_tokens
+  cache_write_unsplit_tokens ANY, -- derived: requests_dedup_computed.cache_write_unsplit_tokens
+  speed                      ANY, -- derived: requests_dedup_computed.speed
+  session_id                 ANY, -- derived: requests_dedup_computed.session_id
+  timestamp_raw              ANY, -- derived: requests_dedup_computed.timestamp_raw
+  timestamp_utc              ANY, -- derived: requests_dedup_computed.timestamp_utc
+  cwd                        ANY, -- derived: requests_dedup_computed.cwd
+  is_sidechain               ANY, -- derived: requests_dedup_computed.is_sidechain
+  root                       ANY, -- derived: requests_dedup_computed.root
+  relative_path              ANY, -- derived: requests_dedup_computed.relative_path
+  first_run_id               ANY, -- derived: requests_dedup_computed.first_run_id
+  line_number                ANY  -- derived: requests_dedup_computed.line_number
+) STRICT;
+
+CREATE INDEX requests_dedup_raw_line_id ON requests_dedup (raw_line_id);
+CREATE INDEX requests_dedup_dedup_key ON requests_dedup (dedup_key);
+CREATE INDEX requests_dedup_time ON requests_dedup (timestamp_utc);
+CREATE INDEX requests_dedup_session_time ON requests_dedup (session_id, timestamp_utc);
+CREATE INDEX requests_dedup_cwd ON requests_dedup (cwd);
+
+INSERT INTO requests_dedup (raw_line_id, dedup_key, message_id, request_id, model, input_tokens, output_tokens, cache_read_tokens, cache_write_5m_tokens, cache_write_1h_tokens, cache_write_unsplit_tokens, speed, session_id, timestamp_raw, timestamp_utc, cwd, is_sidechain, root, relative_path, first_run_id, line_number)
+SELECT raw_line_id, dedup_key, message_id, request_id, model, input_tokens, output_tokens, cache_read_tokens, cache_write_5m_tokens, cache_write_1h_tokens, cache_write_unsplit_tokens, speed, session_id, timestamp_raw, timestamp_utc, cwd, is_sidechain, root, relative_path, first_run_id, line_number FROM requests_dedup_computed;
+
+DROP VIEW window_readings;
+
+-- Observed: one row per observation of a plan window, as 028 computed it; ingest stores its rows in window_readings (D-096). As in 026 (D-044, D-045, D-086), with stale = 1 when a counted reading is more than 1 point below an earlier counted one in its window (D-089).
+CREATE VIEW window_readings_computed AS
+WITH readings AS (
+  SELECT
+    w.raw_line_id, w.window, w.resets_at, w.used_percentage, s.session_id, s.captured_at_s,
+    -- The response behind the latest request line in this session, inside this window, at or before
+    -- the capture (+1 s for whole-second captures). An unkeyed line is its own response.
+    (SELECT COALESCE(rq.dedup_key, 'line:' || rq.raw_line_id)
+       FROM parsed_lines p
+       JOIN requests rq ON rq.raw_line_id = p.raw_line_id
+       WHERE p.session_id = s.session_id AND p.class = 'request'
+         AND p.timestamp_utc > strftime('%Y-%m-%dT%H:%M:%fZ',
+               w.resets_at - CASE w.window WHEN 'five_hour' THEN 5 * 3600 ELSE 7 * 86400 END, 'unixepoch')
+         AND p.timestamp_utc < strftime('%Y-%m-%dT%H:%M:%fZ', s.captured_at_s + 1, 'unixepoch')
+       ORDER BY p.timestamp_utc DESC, p.raw_line_id DESC
+       LIMIT 1) AS response_key
+  FROM rate_limit_windows w
+  JOIN status_readings s ON s.raw_line_id = w.raw_line_id
+  WHERE s.status = 'ok' AND w.validity = 'valid' AND w.window IN ('five_hour', 'seven_day')
+),
+dated AS (
+  SELECT
+    r.*,
+    -- The response's first line: when its numbers first existed.
+    (SELECT MIN(p.timestamp_utc)
+       FROM requests rq
+       JOIN parsed_lines p ON p.raw_line_id = rq.raw_line_id
+       WHERE (r.response_key LIKE 'line:%' AND rq.raw_line_id = CAST(substr(r.response_key, 6) AS INTEGER))
+          OR rq.dedup_key = r.response_key) AS response_first_utc,
+    -- The previous capture of the same response, in capture order.
+    LAG(r.used_percentage) OVER captures AS previous_used_percentage
+  FROM readings r
+  -- A capture-time fallback is its own group: NULL response keys must not merge (D-044).
+  WINDOW captures AS (
+    PARTITION BY r.window, r.resets_at, r.session_id, r.response_key,
+                 CASE WHEN r.response_key IS NULL THEN r.raw_line_id END
+    ORDER BY r.captured_at_s, r.raw_line_id
+  )
+),
+runs AS (
+  SELECT
+    d.*,
+    -- A new run starts at the first capture and at every change of more than 0.01 points: payloads
+    -- carry computed values such as 7.000000000000001, which are the same number (D-044, D-086).
+    SUM(CASE WHEN d.previous_used_percentage IS NULL
+               OR abs(d.used_percentage - d.previous_used_percentage) > 0.01 THEN 1 ELSE 0 END)
+      OVER (
+        PARTITION BY d.window, d.resets_at, d.session_id, d.response_key,
+                     CASE WHEN d.response_key IS NULL THEN d.raw_line_id END
+        ORDER BY d.captured_at_s, d.raw_line_id
+        ROWS UNBOUNDED PRECEDING
+      ) AS run
+  FROM dated d
+),
+observed AS (
+  SELECT
+    u.*,
+    -- A later run's value didn't come from the response, so it's dated when it was first seen.
+    CASE
+      WHEN u.response_first_utc IS NULL THEN strftime('%Y-%m-%dT%H:%M:%fZ', u.captured_at_s, 'unixepoch')
+      WHEN u.run = 1 THEN u.response_first_utc
+      ELSE strftime('%Y-%m-%dT%H:%M:%fZ', MIN(u.captured_at_s) OVER run_captures, 'unixepoch')
+    END AS observed_at_utc,
+    ROW_NUMBER() OVER run_captures_latest AS copy_rank
+  FROM runs u
+  WINDOW
+    run_captures AS (
+      PARTITION BY u.window, u.resets_at, u.session_id, u.response_key,
+                   CASE WHEN u.response_key IS NULL THEN u.raw_line_id END, u.run
+    ),
+    run_captures_latest AS (
+      PARTITION BY u.window, u.resets_at, u.session_id, u.response_key,
+                   CASE WHEN u.response_key IS NULL THEN u.raw_line_id END, u.run
+      ORDER BY u.captured_at_s DESC, u.raw_line_id DESC
+    )
+),
+counted AS (
+  SELECT
+    raw_line_id,
+    window,
+    resets_at,
+    strftime('%Y-%m-%dT%H:%M:%fZ', resets_at, 'unixepoch') AS reset_at_utc,
+    used_percentage,
+    session_id,
+    captured_at_s,
+    strftime('%Y-%m-%dT%H:%M:%fZ', captured_at_s, 'unixepoch') AS captured_at_utc,
+    observed_at_utc,
+    unixepoch(observed_at_utc, 'subsec') AS observed_at_s,
+    CASE
+      WHEN response_key IS NULL THEN 'capture'
+      WHEN run = 1 THEN 'last_request'
+      ELSE 'changed_capture'
+    END AS observed_via,
+    unixepoch(observed_at_utc, 'subsec') > resets_at AS after_reset
+  FROM observed
+  WHERE copy_rank = 1
+)
+SELECT
+  c.*,
+  -- Usage within one window only rises, so a counted reading more than 1 point below an earlier one
+  -- in the same window, from any session, carries a number from before that earlier reading (D-089).
+  CASE
+    WHEN c.after_reset = 0 AND c.used_percentage < MAX(c.used_percentage) OVER (
+      PARTITION BY c.window, c.resets_at ORDER BY c.observed_at_s, c.raw_line_id
+      ROWS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING
+    ) - 1 THEN 1
+    ELSE 0
+  END AS stale
+FROM counted c;
+
+CREATE TABLE window_readings (
+  raw_line_id     ANY, -- derived: window_readings_computed.raw_line_id
+  window          ANY, -- derived: window_readings_computed.window
+  resets_at       ANY, -- derived: window_readings_computed.resets_at
+  reset_at_utc    ANY, -- derived: window_readings_computed.reset_at_utc
+  used_percentage ANY, -- derived: window_readings_computed.used_percentage
+  session_id      ANY, -- derived: window_readings_computed.session_id
+  captured_at_s   ANY, -- derived: window_readings_computed.captured_at_s
+  captured_at_utc ANY, -- derived: window_readings_computed.captured_at_utc
+  observed_at_utc ANY, -- derived: window_readings_computed.observed_at_utc
+  observed_at_s   ANY, -- derived: window_readings_computed.observed_at_s
+  observed_via    ANY, -- derived: window_readings_computed.observed_via
+  after_reset     ANY, -- derived: window_readings_computed.after_reset
+  stale           ANY  -- derived: window_readings_computed.stale
+) STRICT;
+
+CREATE INDEX window_readings_raw_line ON window_readings (raw_line_id);
+CREATE INDEX window_readings_instance ON window_readings (window, reset_at_utc, observed_at_s);
+CREATE INDEX window_readings_session_time ON window_readings (session_id, observed_at_s);
+CREATE INDEX window_readings_time ON window_readings (observed_at_utc);
+
+INSERT INTO window_readings (raw_line_id, window, resets_at, reset_at_utc, used_percentage, session_id, captured_at_s, captured_at_utc, observed_at_utc, observed_at_s, observed_via, after_reset, stale)
+SELECT raw_line_id, window, resets_at, reset_at_utc, used_percentage, session_id, captured_at_s, captured_at_utc, observed_at_utc, observed_at_s, observed_via, after_reset, stale FROM window_readings_computed;
+
+-- Statistics for the query planner, so the first report after this migration is fast too (D-096).
+ANALYZE;

package/dist/cli/main.cli.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+/**
+ * @file Command-line entry point. Holds no logic, so it is excluded from coverage; everything it
+ * runs is tested through `checkNodeVersion()` in node-version.ts, `runCli()` in program.ts, and
+ * the CLI integration tests.
+ */
+import { homedir } from "node:os";
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { checkNodeVersion } from "../core/util/node-version.js";
+// Checked before the program is imported: on an older Node.js, the built-in `node:sqlite` is missing
+// (22.11 throws on import without a flag) or experimental (22.23 warns on every run), and Nilometer
+// isn't tested there (D-066, D-093). The program is loaded with a dynamic import below so nothing
+// that loads `node:sqlite` runs before this check.
+const nodeCheck = checkNodeVersion(process.versions.node);
+if (nodeCheck.message !== undefined) {
+    console.error(nodeCheck.message);
+}
+if (nodeCheck.status === "too_old") {
+    process.exitCode = 1;
+}
+else {
+    const { findPackageRoot } = await import("../core/install/locations.js");
+    const { runCli } = await import("./program.js");
+    process.exitCode = runCli(process.argv.slice(2), {
+        home: homedir(),
+        env: process.env,
+        packageRoot: findPackageRoot(dirname(fileURLToPath(import.meta.url))),
+        now: () => new Date(),
+        print: (line) => {
+            console.log(line);
+        },
+        printError: (line) => {
+            console.error(line);
+        },
+        timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    });
+}
+//# sourceMappingURL=main.cli.js.map