tina4-nodejs 3.13.92 → 3.13.94

package/types/core/src/container.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Lightweight dependency injection container.
+ *
+ * Matches the Python tina4_python.container.Container API.
+ *
+ *   import { Container, container } from "@tina4/core";
+ *
+ *   container.register("mailer", () => new MailService());
+ *   container.singleton("db", () => new Database("sqlite:///app.db"));
+ *
+ *   const mailer = container.get<MailService>("mailer"); // new instance each call
+ *   const db     = container.get<Database>("db");        // same instance every call
+ *
+ * Node.js is single-threaded so no locking is needed.
+ */
+export declare class Container {
+    private transients;
+    private singletons;
+    private instances;
+    /**
+     * Register a transient factory — a new instance is created on every `get()` call.
+     */
+    register(name: string, factory: () => unknown): void;
+    /**
+     * Register a singleton factory — created once on first `get()`, then memoised.
+     */
+    singleton(name: string, factory: () => unknown): void;
+    /**
+     * Resolve a dependency by name.
+     *
+     * Throws an `Error` if the name has not been registered.
+     */
+    get<T = unknown>(name: string): T;
+    /**
+     * Return `true` if *name* has been registered (transient or singleton).
+     */
+    has(name: string): boolean;
+    /**
+     * Clear all registrations and cached instances.
+     */
+    reset(): void;
+}
+/** Default container instance. */
+export declare const container: Container;

package/types/core/src/context/chunker.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Lowercase, strip diacritics, join comma-grouped numbers, split camelCase.
+ *
+ * Applied symmetrically to the indexed `body` and to query tokens so matching
+ * is consistent: a query for `field` reaches `IntegerField`. The trailing
+ * NFKD-normalise + strip-non-ASCII mirrors python's
+ * `unicodedata.normalize("NFKD", ...).encode("ascii", "ignore")`.
+ */
+export declare function fold(text: string): string;
+/**
+ * Fold simple plurals: strip one trailing 's', never from ss/us/is endings
+ * (class, status, axis). QUERY-side only — so `fields` in a question also
+ * reaches `Field` definitions.
+ */
+export declare function lightStem(token: string): string;
+/** Accent-folded lowercase alphanumeric tokens (digits kept). */
+export declare function terms(text: string): string[];
+/**
+ * Chunk source on top-level def/class/decorator boundaries (sentence chunking
+ * shreds code). Segments are packed up to `maxLines`, and every chunk starts
+ * with a `# file: <path>` line so the path's tokens are indexed — 'where is the
+ * router?' should match core/router.ts by name.
+ *
+ * Returns a list of `[index, chunkText]` pairs.
+ */
+export declare function chunkCode(text: string, path?: string, maxLines?: number): Array<[number, string]>;
+/**
+ * Chunk prose/docs into sentence-packed windows of at most `maxWords` words.
+ * Returns a list of `[index, chunkText]` pairs.
+ */
+export declare function chunkText(text: string, maxWords?: number): Array<[number, string]>;

package/types/core/src/context/index.d.ts

@@ -0,0 +1,93 @@
+/** True if this build of node:sqlite supports FTS5. */
+export declare function fts5Supported(): boolean;
+export interface SearchHit {
+    path: string;
+    score: number;
+    snippet: string;
+}
+/**
+ * A SQLite FTS5 index over a project's source + docs.
+ *
+ * - indexPath(file, label?)  upsert one file (delete-by-path, re-chunk, insert)
+ * - indexRoot(root)          walk a tree, index every eligible file
+ * - search(query, k)         [{path, score, snippet}] ranked by bm25() with
+ *                            source-over-tests + definition-first reordering
+ * - reindexFile(changed)     upsert one changed file against the indexed root
+ */
+export declare class Context {
+    path: string;
+    root: string | null;
+    available: boolean;
+    private conn;
+    /**
+     * @param dbPath    on-disk index file (its parent dir is created).
+     * @param fts5Check overrides FTS5 detection (used by tests to exercise the
+     *                  graceful-degradation path); defaults to a real probe.
+     */
+    constructor(dbPath?: string, fts5Check?: () => boolean);
+    /** Whether this Node build's node:sqlite supports FTS5. */
+    static fts5Available(): boolean;
+    private ensureTable;
+    /** Drop and recreate the index (full rebuild starting point). */
+    reset(): void;
+    private static chunksFor;
+    /**
+     * UPSERT one file into the index: delete this path's existing chunks,
+     * re-chunk the current contents, insert. `label` is the stored/citation path
+     * (defaults to `file`) and MUST be stable across calls for the same file so
+     * the delete targets the right rows. Returns rows inserted.
+     */
+    indexPath(file: string, label?: string): number;
+    /**
+     * The per-file filter used by both indexRoot and reindexFile. Directory
+     * skipping is handled separately.
+     */
+    private static eligible;
+    /**
+     * Walk `root`, indexing every eligible file (skips vendor/build/runtime
+     * dirs). Paths are stored RELATIVE to `root` for clean citations. Records
+     * `root` so reindexFile can relabel a changed file consistently. Returns the
+     * total number of chunks inserted.
+     */
+    indexRoot(root: string): number;
+    /**
+     * Re-index a single changed file into the LIVE index — the hook the dev
+     * WebSocket reload trigger (POST /__dev/api/reload) calls so code_search
+     * tracks edits without a rebuild. Resolves `changedPath` against the indexed
+     * root, then: outside root / under a skip-or-dot dir / ineligible → skip (-1);
+     * deleted → drop its chunks (0); otherwise UPSERT (rows). No-op (-1) until
+     * indexRoot has run (nothing to keep fresh yet).
+     */
+    reindexFile(changedPath: string): number;
+    private matchExpr;
+    private static isTestlike;
+    private static defines;
+    /**
+     * Return the top-`k` chunks as `[{path, score, snippet}]`, ranked by `bm25()`
+     * then reordered with two stable, proven passes:
+     *   - source-over-tests: a test that merely mentions a symbol sinks below the
+     *     source that defines it (skipped when the query is about tests);
+     *   - definition-first: a chunk that DEFINES a queried symbol rises above
+     *     chunks that only use it.
+     * Score is a higher-is-better float (sqlite's bm25 sign flipped).
+     */
+    search(query: string, k?: number): SearchHit[];
+    private static snippet;
+    count(): number;
+    isEmpty(): boolean;
+    close(): void;
+}
+export declare const _sharedContexts: Map<string, Context>;
+/**
+ * Get (or create) the process-wide Context at `db` (default
+ * `<cwd>/.tina4/context.db`). If `root` is given and the index is empty, builds
+ * it once. This is what code_search uses so the reload hook can keep the SAME
+ * index fresh.
+ */
+export declare function defaultContext(root?: string, db?: string): Context;
+/**
+ * Return the already-created shared Context for `db` (or undefined). Used by the
+ * reload hook so a file change reindexes an EXISTING index but never creates one
+ * on its own (nothing to keep fresh until code_search runs).
+ */
+export declare function existingContext(db?: string): Context | undefined;

package/types/core/src/devAdmin.d.ts

@@ -0,0 +1,179 @@
+/**
+ * Tina4 Dev Admin — Built-in development dashboard, zero dependencies.
+ *
+ * Auto-registered admin panel for development mode.
+ * Provides API endpoints and a single-page UI at /__dev/ for:
+ *   - Route inspector (all registered routes, methods)
+ *   - Message log (tracked debug messages)
+ *   - Request inspector (captured HTTP requests)
+ *   - System info (Node.js version, V8, memory, uptime, platform)
+ */
+import type { Router } from "./router.js";
+interface LogEntry {
+    id: string;
+    timestamp: string;
+    category: string;
+    level: string;
+    message: string;
+    data?: unknown;
+}
+interface RequestEntry {
+    id: string;
+    timestamp: string;
+    method: string;
+    path: string;
+    status: number;
+    durationMs: number;
+}
+interface RequestStats {
+    total: number;
+    avgMs: number;
+    errors: number;
+    slowestMs: number;
+}
+interface ErrorEntry {
+    id: string;
+    timestamp: string;
+    message: string;
+    stack?: string;
+    resolved: boolean;
+}
+interface QueueJob {
+    id: string;
+    timestamp: string;
+    name: string;
+    status: "pending" | "completed" | "failed" | "reserved";
+    payload?: unknown;
+    result?: unknown;
+    error?: string;
+}
+interface WsConnection {
+    id: string;
+    connectedAt: string;
+    remoteAddress: string;
+    path: string;
+}
+export declare class MessageLog {
+    private static messages;
+    private static maxMessages;
+    static log(category: string, level: string, message: string, data?: unknown): void;
+    static get(category?: string, limit?: number): LogEntry[];
+    static clear(category?: string): void;
+    static count(): Record<string, number>;
+}
+export declare class RequestInspector {
+    private static requests;
+    private static maxRequests;
+    static capture(method: string, path: string, status: number, duration: number): void;
+    static get(limit?: number): RequestEntry[];
+    static stats(): RequestStats;
+    static clear(): void;
+}
+export declare class ErrorTracker {
+    private static errors;
+    private static maxErrors;
+    private static registered;
+    /**
+     * Capture an error with dedup (matches PHP/Ruby/Python signature).
+     * Duplicate errors (same message) increment count and update last_seen.
+     */
+    static capture(errorType: string, message: string, traceback?: string, file?: string, line?: number): void;
+    /** Legacy alias for capture (backward compatibility). */
+    static track(message: string, stack?: string): void;
+    static get(): ErrorEntry[];
+    static resolve(id: string): boolean;
+    static clearResolved(): void;
+    /** Remove ALL tracked errors. */
+    static clearAll(): void;
+    /** Health summary — are there unresolved errors? */
+    static health(): {
+        healthy: boolean;
+        total: number;
+        unresolved: number;
+        resolved: number;
+    };
+    /** Count of unresolved errors. */
+    static unresolvedCount(): number;
+    /** Reset all state (for testing). */
+    static reset(): void;
+    /**
+     * Register global error handlers to feed the tracker.
+     * Safe to call multiple times — only registers once.
+     */
+    static register(): void;
+}
+export declare class DevMailboxStore {
+    private static mailbox;
+    static inbox(folder?: string, limit?: number, offset?: number): import("./messenger.js").EmailMessage[];
+    static read(id: string): import("./messenger.js").EmailMessage | null;
+    static seed(count?: number): void;
+    static clear(folder?: string): void;
+    static unreadCount(): number;
+    static count(folder?: string): {
+        inbox: number;
+        outbox: number;
+        total: number;
+    };
+}
+export declare class DevQueue {
+    private static jobs;
+    static stats(): {
+        pending: number;
+        completed: number;
+        failed: number;
+        reserved: number;
+        jobs: QueueJob[];
+    };
+    static add(name: string, payload?: unknown): QueueJob;
+    static retryFailed(): number;
+    static purgeCompleted(): number;
+    static replay(id: string): QueueJob | undefined;
+}
+export declare class WsTracker {
+    private static connections;
+    static add(remoteAddress: string, path: string): string;
+    static remove(id: string): boolean;
+    static list(): WsConnection[];
+}
+export declare class DevAdmin {
+    /**
+     * Check whether dev mode is enabled.
+     */
+    static isEnabled(): boolean;
+    /**
+     * Register all /__dev routes on the given router.
+     */
+    static register(router: Router): void;
+    /**
+     * Returns the dev toolbar HTML to inject into HTML pages.
+     */
+    static renderToolbarHtml(ctx: {
+        version: string;
+        method: string;
+        path: string;
+        matchedPattern: string;
+        requestId: string;
+        routeCount: number;
+    }): string;
+}
+/**
+ * Return the base URL for the co-located Rust agent server.
+ *
+ * Mirrors Python's `_supervisor_base_url()` in
+ * `tina4_python/dev_admin/__init__.py`. Resolution order:
+ *   1. `TINA4_SUPERVISOR_URL` — explicit full URL.
+ *   2. `TINA4_AGENT_PORT` — explicit port on 127.0.0.1.
+ *   3. `PORT` + 2000 — auto-derived (matches `tina4 serve` agent port).
+ *   4. Fallback `http://127.0.0.1:9145` — matches standalone `tina4 agent`.
+ */
+export declare function supervisorBaseUrl(): string;
+/**
+ * Resolve a CodeMirror-friendly language id from a file path's basename.
+ *
+ * - `Dockerfile` / `Dockerfile.dev` / `Dockerfile.prod` (no extension) → "dockerfile"
+ * - `.env.example` (two-part) and `.env` → "env"
+ * - otherwise the file extension is looked up in DEV_ADMIN_LANG_MAP
+ * - anything unknown → "text"
+ */
+export declare function devAdminLanguage(rel: string): string;
+export {};

package/types/core/src/devMailbox.d.ts

@@ -0,0 +1,54 @@
+import type { SendResult, EmailMessage } from "./messenger.js";
+export declare class DevMailbox {
+    private mailboxDir;
+    constructor(mailboxDir?: string);
+    /**
+     * Ensure a folder directory exists.
+     */
+    private ensureFolder;
+    /**
+     * Capture an email to the dev mailbox instead of sending it.
+     *
+     * The parameter order MATCHES Messenger.send() on purpose. It did not before:
+     * send()'s 5th positional was `text` and capture()'s was `cc`, so the same call
+     * meant different things depending on which door it came through -- that mismatch
+     * IS nodejs#42.
+     *
+     * BREAKING: `text` is now the 5th positional. A caller passing cc positionally
+     * must move it. Aligning the two signatures is the fix; leaving them apart would
+     * preserve the bug.
+     */
+    capture(to: string | string[], subject: string, body: string, html?: boolean, text?: string, cc?: string | string[], bcc?: string | string[], replyTo?: string, attachments?: string[], from?: string): SendResult;
+    /**
+     * List messages from a folder (default: inbox).
+     */
+    inbox(limit?: number, offset?: number, folder?: string): EmailMessage[];
+    /**
+     * Read a single message by ID. Searches all folders.
+     */
+    read(msgId: string): EmailMessage | null;
+    /**
+     * Count unread messages in the inbox.
+     */
+    unreadCount(): number;
+    /**
+     * Delete a message by ID. Removes from all folders.
+     */
+    delete(msgId: string): boolean;
+    /**
+     * Clear all messages from a folder, or all folders if none specified.
+     */
+    clear(folder?: string): void;
+    /**
+     * Seed the mailbox with sample messages for development.
+     */
+    seed(count?: number): void;
+    /**
+     * Count messages in a folder, or all folders if none specified.
+     */
+    count(folder?: string): {
+        inbox: number;
+        outbox: number;
+        total: number;
+    };
+}

package/types/core/src/docs.d.ts

@@ -0,0 +1,141 @@
+/**
+ * Tina4 Live API RAG — `Docs` module.
+ *
+ * Walks framework packages (`@tina4/core`, `@tina4/orm`, `@tina4/swagger`,
+ * `@tina4/frond`) and the user project's `src/` tree via lightweight TS
+ * regex parsing (no AST — works on .ts files without importing them, so
+ * user-code import errors don't break reflection).
+ *
+ * Exposes ranked search, class/method specs, a flat index, MCP-style
+ * static mirrors, and a Markdown drift/sync helper. Zero new runtime
+ * dependencies — Node stdlib only.
+ *
+ * Spec: plan/v3/22-LIVE-API-RAG.md
+ *
+ * Method names follow Tina4 Node.js convention (camelCase) — see PHP
+ * `Tina4\Docs` and Python `tina4_python.docs.Docs` for parity references.
+ */
+export interface DocsHit {
+    fqn: string;
+    kind: "class" | "method" | "function" | "property";
+    name: string;
+    signature: string;
+    summary: string;
+    file: string;
+    line: number;
+    version: string;
+    source: "framework" | "user" | "vendor";
+    visibility: "public" | "protected" | "private";
+    static?: boolean;
+    class?: string;
+    score: number;
+}
+export interface MethodSpec {
+    name: string;
+    fqn: string;
+    class: string;
+    kind: "method";
+    signature: string;
+    summary: string;
+    docblock: string;
+    file: string;
+    line: number;
+    visibility: "public" | "protected" | "private";
+    static: boolean;
+    source: "framework" | "user" | "vendor";
+    version: string;
+    params: Array<{
+        name: string;
+        type: string;
+        default?: string | null;
+    }>;
+    return: string;
+}
+export interface ClassSpec {
+    fqn: string;
+    kind: "class";
+    name: string;
+    file: string;
+    line: number;
+    summary: string;
+    docblock: string;
+    source: "framework" | "user" | "vendor";
+    version: string;
+    methods: Array<Omit<MethodSpec, "params" | "return"> & {
+        params?: unknown[];
+        return?: string;
+    }>;
+    properties: unknown[];
+}
+export interface IndexEntry {
+    fqn: string;
+    kind: "class" | "method" | "function" | "property";
+    name: string;
+    signature: string;
+    summary: string;
+    file: string;
+    line: number;
+    version: string;
+    source: "framework" | "user" | "vendor";
+    visibility: "public" | "protected" | "private";
+    static?: boolean;
+    class?: string;
+}
+export interface DriftHit {
+    method: string;
+    line: number;
+    block: string;
+}
+export declare class Docs {
+    private projectRoot;
+    private frameworkRoots;
+    private version;
+    private indexCache;
+    private frameworkEntries;
+    private userEntries;
+    private userMtime;
+    private frameworkMtime;
+    constructor(projectRoot: string);
+    /**
+     * Search the merged framework + user index for query-matching entities.
+     * Source filter accepts `all` (default), `framework`, `user`, `vendor`.
+     * Private/underscore methods are excluded unless `includePrivate=true`.
+     */
+    search(query: string, k?: number, source?: string, includePrivate?: boolean): DocsHit[];
+    /**
+     * Resolve a class by exact FQN, documented public import path, or bare name.
+     *
+     * Node stores the bare class name as the FQN (`Database`), but a developer
+     * reading the docs may type the published path (`@tina4/orm.Database`,
+     * `orm/Database`) or just `Database`. Match exactly first, then by class
+     * name (last path segment), disambiguating by requiring the given segments
+     * to appear in the stored FQN/file (framework + shortest wins). Unknown
+     * names stay `null` — no false positives.
+     */
+    private resolveClassEntry;
+    /**
+     * Return the full spec for a single class, or `null` if not found.
+     */
+    classSpec(fqn: string): ClassSpec | null;
+    /**
+     * Return the spec for a single method, or `null` if unknown.
+     */
+    methodSpec(classFqn: string, methodName: string): MethodSpec | null;
+    /**
+     * Flat list of every reflected entity (classes + methods + functions),
+     * user + framework. Vendor entries are included here for completeness.
+     */
+    index(): IndexEntry[];
+    static mcpSearch(query: string, k?: number, projectRoot?: string, source?: string, includePrivate?: boolean): DocsHit[];
+    static mcpMethod(classFqn: string, name: string, projectRoot?: string): MethodSpec | null;
+    static mcpClass(fqn: string, projectRoot?: string): ClassSpec | null;
+    static checkDocs(mdPath: string, projectRoot?: string): {
+        drift: DriftHit[];
+    };
+    static syncDocs(mdPath: string, projectRoot?: string): void;
+    private static cached;
+    private ensureIndex;
+    private maxMtime;
+    private scoreEntry;
+    private renderGeneratedBlock;
+}

package/types/core/src/docsAutoDiscovery.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Write `.tina4/mcp.json` and (if `.git/` exists) append `.tina4/` to .gitignore.
+ *
+ * Returns true if the discovery file was written or updated.
+ */
+export declare function writeMcpDiscovery(projectRoot: string, port: number): boolean;

package/types/core/src/dotenv.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Load environment variables from a .env file into process.env.
+ *
+ * By default does NOT override existing process.env values — it is first-wins:
+ * a key is only set if it is not already present. This is how real env vars
+ * always win. To get the precedence real-env > `.env.local` > `.env`, load
+ * `.env.local` FIRST then `.env`, both with override=false (the default): the
+ * real env (already present) wins over both, `.env.local` fills local-only keys,
+ * and `.env` fills the rest. Do NOT load `.env.local` with override=true — that
+ * would let a stray gitignored `.env.local` clobber an explicitly set real env
+ * var (e.g. a production TINA4_SECRET).
+ *
+ * Resolution order for the env file path:
+ *   1. Explicit `path` argument
+ *   2. `TINA4_ENV_FILE` env var (if set and non-empty)
+ *   3. `.env` in the current working directory
+ *
+ * @param path     - Path to the .env file. Optional override.
+ * @param override - When true, overwrite keys already present in process.env.
+ * @returns The parsed key-value pairs, or an empty object if the file doesn't exist.
+ */
+export declare function loadEnv(path?: string, override?: boolean): Record<string, string>;
+/**
+ * Get an environment variable value with an optional default.
+ *
+ * @param key - The environment variable name.
+ * @param defaultValue - Value to return if the variable is not set.
+ * @returns The environment variable value, or the default.
+ */
+export declare function getEnv(key: string, defaultValue?: string): string | undefined;
+/**
+ * Get a required environment variable. Throws if not set.
+ *
+ * @param key - The environment variable name.
+ * @returns The environment variable value.
+ * @throws Error if the variable is not set.
+ */
+export declare function requireEnv(key: string): string;
+/**
+ * Check if an environment variable exists (is defined in process.env).
+ *
+ * @param key - The environment variable name.
+ * @returns true if the variable is set, false otherwise.
+ */
+export declare function hasEnv(key: string): boolean;
+/**
+ * Return all currently loaded environment variables.
+ *
+ * @returns A shallow copy of process.env as a record.
+ */
+export declare function allEnv(): Record<string, string | undefined>;
+/**
+ * Check if a value is truthy for env boolean checks.
+ *
+ * Accepts: "true", "True", "TRUE", "1", "yes", "Yes", "YES", "on", "On", "ON".
+ * Everything else is falsy (including empty string, undefined, not set).
+ *
+ * Mirrors Python's `is_truthy()` in `tina4_python.dotenv`.
+ */
+export declare function isTruthy(val: string | undefined | null): boolean;
+/**
+ * Remove all environment variables that were loaded by loadEnv().
+ * Useful for testing. Only removes keys set by loadEnv(), not pre-existing system env vars.
+ */
+export declare function resetEnv(): void;

package/types/core/src/env.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Typed environment-variable helpers.
+ *
+ * All methods are static so callers can write `Env.bool(...)` without
+ * instantiating anything — matching the Python/PHP/Ruby ports.
+ */
+export declare class Env {
+    /**
+     * Read `name` and coerce to bool.
+     *
+     * Truthy values (case-insensitive after trim): `1`, `true`, `on`, `yes`,
+     * `y`, `t`. Falsy: `0`, `false`, `off`, `no`, `n`, `f`, empty string.
+     * Anything else returns the `defaultValue` — never throws.
+     */
+    static bool(name: string, defaultValue?: boolean): boolean;
+    /** Read `name` and coerce to int. Returns `defaultValue` on parse failure. */
+    static int(name: string, defaultValue?: number): number;
+    /** Read `name` and coerce to float. Returns `defaultValue` on parse failure. */
+    static float(name: string, defaultValue?: number): number;
+    /**
+     * Read `name` as a string. Returns `defaultValue` if unset.
+     *
+     * Whitespace is preserved — this is a pass-through for the raw env value.
+     * `Env.str("PATH")` is exactly `process.env.PATH ?? ""` with a more
+     * discoverable name.
+     */
+    static str(name: string, defaultValue?: string): string;
+}

package/types/core/src/errorOverlay.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Tina4 Debug — Rich error overlay for development mode.
+ *
+ * Renders a professional, syntax-highlighted HTML error page when an unhandled
+ * exception occurs in a route handler.
+ *
+ *   import { renderErrorOverlay, renderProductionError, isDebugMode } from "./errorOverlay.js";
+ *
+ *   try {
+ *     await handler(req, res);
+ *   } catch (err) {
+ *     const html = isDebugMode()
+ *       ? renderErrorOverlay(err as Error, req)
+ *       : renderProductionError();
+ *     res.html(html, 500);
+ *   }
+ *
+ * Only activate when TINA4_DEBUG is true.
+ * In production, call renderProductionError() instead.
+ */
+/**
+ * Render a rich HTML error overlay.
+ *
+ * @param error - The caught error.
+ * @param request - Optional request object with method, url, headers, etc.
+ * @returns Complete HTML page string.
+ */
+export declare function renderErrorOverlay(error: Error, request?: any): string;
+/**
+ * Render a safe, generic error page for production.
+ */
+export declare function renderProductionError(statusCode?: number, message?: string, path?: string): string;
+/**
+ * Check if TINA4_DEBUG is enabled.
+ */
+export declare function isDebugMode(): boolean;