@leftium/gg 0.0.47 → 0.0.49

package/README.md

@@ -6,7 +6,8 @@
   - Each namespace gets a unique color for easier visual parsing.
   - Simple syntax with wildcards to filter/hide debug output at runtime.
   - Millisecond diff (timestamps) for each namespace.
-- Can be inserted into the middle of expressions (returns the value of the first argument).
+- Chainable API: `.ns()`, `.warn()`, `.error()`, `.info()`, `.trace()`, `.table()`.
+- Can be inserted into the middle of expressions (use `.v` to get the passthrough value).
 - Can output a link that opens the source file in your editor (like VS Code).
 - Simple to disable (turn all loggs into NOP's for production).
 - Diagnostics/hints in dev console & terminal to help install and configure correctly.
@@ -28,8 +29,12 @@ npm add @leftium/gg
 
 	gg('Hello world');
 
-	// Log expressions (returns first argument)
-	const result = gg(someFunction());
+	// Log with modifiers
+	gg('Connection timeout').warn();
+	gg('User authenticated', user).info();
+
+	// Passthrough with .v (returns the first argument)
+	const result = gg(someFunction()).v;
 
 	// Multiple arguments
 	gg('User:', user, 'Status:', status);
@@ -57,11 +62,10 @@ export default defineConfig({
 
 - **Call-sites plugin** -- rewrites `gg()` calls with source file/line/col metadata
 - **Open-in-editor plugin** -- adds dev server middleware for click-to-open
-- **Automatic `es2022` target** -- required for top-level await
 
 ### 3. Add the debug console (optional, recommended)
 
-An in-browser debug console (powered by Eruda) with a dedicated GG tab for filtering and inspecting logs — especially useful on mobile.
+An in-browser debug console (powered by Eruda) with a dedicated GG tab for filtering and inspecting logs -- especially useful on mobile.
 
 ```svelte
 <!-- src/routes/+layout.svelte -->
@@ -76,6 +80,173 @@ An in-browser debug console (powered by Eruda) with a dedicated GG tab for filte
 In development, the debug console appears automatically.
 In production, add `?gg` to the URL or use a 5-tap gesture to activate.
 
+## Chaining API
+
+`gg()` returns a `GgChain<T>` with composable modifiers. Chain any combination, in any order. The log auto-flushes on the next microtask, or use `.v` to flush immediately and get the passthrough value.
+
+```javascript
+import { gg } from '@leftium/gg';
+
+// Basic logging (auto-flushes on microtask)
+gg('hello');
+gg('multiple', 'args', { data: 42 });
+
+// Passthrough with .v (flushes immediately, returns first arg)
+const result = gg(computeValue()).v;
+const user = gg(await fetchUser()).ns('api').v;
+
+// Log levels
+gg('System ready').info(); // blue indicator
+gg('Deprecated API call').warn(); // yellow indicator
+gg('Connection failed').error(); // red indicator + stack trace
+
+// Custom namespace
+gg('Processing request').ns('api:handler');
+
+// Stack trace
+gg('Debug checkpoint').trace();
+
+// Table formatting (also emits native console.table)
+gg(arrayOfObjects).table();
+gg(data).table(['name', 'age']); // filter columns
+
+// Combine modifiers freely
+gg('Slow query', { ms: 3200 }).ns('db').warn();
+const rows = gg(queryResult).ns('db:query').table().v;
+```
+
+### `.v` -- Passthrough
+
+Use `.v` at the end of any chain to flush the log immediately and return the first argument. This lets you insert `gg()` into the middle of expressions:
+
+```javascript
+// Without .v: logs on microtask, returns GgChain (not the value!)
+gg(someValue);
+
+// With .v: logs immediately, returns someValue
+const x = gg(someValue).v;
+const y = gg(compute()).ns('math').warn().v;
+
+// Insert into expressions
+processData(gg(inputData).v);
+return gg(result).ns('output').v;
+```
+
+### `.ns(label)` -- Custom Namespace
+
+Override the auto-generated namespace (file@function) with a custom label. Useful for grouping related logs across files:
+
+```javascript
+gg('Request received').ns('api:incoming');
+gg('Response sent').ns('api:outgoing');
+gg('Cache hit').ns('api:cache');
+```
+
+Namespace labels support **template variables** that resolve from plugin-provided metadata:
+
+| Variable | Description                   | Example                           |
+| -------- | ----------------------------- | --------------------------------- |
+| `$NS`    | Full auto-generated callpoint | `routes/+page.svelte@handleClick` |
+| `$FN`    | Enclosing function name       | `handleClick`                     |
+| `$FILE`  | Source file path              | `routes/+page.svelte`             |
+| `$LINE`  | Line number                   | `42`                              |
+| `$COL`   | Column number                 | `3`                               |
+
+```javascript
+gg('debug info').ns('ERROR:$NS'); // → ERROR:routes/+page.svelte@handleClick
+gg('validation').ns('$FILE:validate'); // → routes/+page.svelte:validate
+gg('step 1').ns('TRACE:$FN'); // → TRACE:handleClick
+gg('context').ns('$NS:debug'); // → routes/+page.svelte@handleClick:debug
+```
+
+Without the Vite plugin, `$NS` falls back to a runtime word-tuple (e.g. `calm-fox`). `$FN`, `$FILE`, `$LINE`, and `$COL` require the plugin.
+
+### `.info()` / `.warn()` / `.error()` -- Log Levels
+
+```javascript
+gg('Server started on port 3000').info(); // blue badge
+gg('Rate limit approaching').warn(); // yellow badge
+gg('Unhandled exception').error(); // red badge + captures stack
+
+// .error() with an Error object uses its .stack
+try {
+	riskyOperation();
+} catch (err) {
+	gg(err).error();
+}
+```
+
+### `.trace()` -- Stack Trace
+
+Captures a full stack trace (cleaned of internal gg frames) alongside the log entry:
+
+```javascript
+gg('How did we get here?').trace();
+```
+
+### `.table(columns?)` -- Table Formatting
+
+Formats the first argument as a table. Also emits a native `console.table()` call. Optionally filter columns:
+
+```javascript
+gg([
+	{ name: 'Alice', age: 30, role: 'admin' },
+	{ name: 'Bob', age: 25, role: 'user' }
+]).table();
+
+// Filter columns
+gg(users).table(['name', 'role']);
+
+// Works with objects-of-objects and arrays of primitives too
+gg({ us: { pop: '331M' }, uk: { pop: '67M' } }).table();
+gg(['apple', 'banana', 'cherry']).table();
+```
+
+## Timers
+
+Measure elapsed time with `gg.time()`, `gg.timeLog()`, and `gg.timeEnd()`:
+
+```javascript
+import { gg } from '@leftium/gg';
+
+gg.time('fetch');
+
+// ... some work ...
+gg.timeLog('fetch', 'headers received'); // logs elapsed without stopping
+
+// ... more work ...
+gg.timeEnd('fetch'); // logs elapsed and stops timer
+```
+
+### Timer Namespaces
+
+`gg.time()` returns a `GgTimerChain` that supports `.ns()` for grouping. The namespace is inherited by subsequent `timeLog` and `timeEnd` calls for the same label:
+
+```javascript
+gg.time('fetch').ns('api-pipeline');
+
+gg.timeLog('fetch', 'step 1 done'); // logged under 'api-pipeline'
+gg.timeEnd('fetch'); // logged under 'api-pipeline'
+
+// Template variables work too
+gg.time('db-query').ns('$FN:timers');
+```
+
+## `gg.here()` -- Open in Editor
+
+Returns call-site metadata for rendering "open in editor" links. Replaces the old no-arg `gg()` introspection.
+
+```svelte
+<script>
+	import { gg } from '@leftium/gg';
+</script>
+
+<!-- Pass to a link component -->
+<OpenInEditorLink gg={gg.here()} />
+```
+
+Returns `{ fileName, functionName, url }` where `url` points to the dev server's open-in-editor endpoint.
+
 ## GgConsole Options
 
 ```svelte
@@ -226,6 +397,40 @@ initGgEruda();
 gg('works in any framework');
 ```
 
+## API Reference
+
+### `gg(value, ...args)` -- Returns `GgChain<T>`
+
+| Method / Property | Description                                   |
+| ----------------- | --------------------------------------------- |
+| `.v`              | Flush log immediately, return first argument  |
+| `.ns(label)`      | Set custom namespace (supports template vars) |
+| `.info()`         | Set log level to info                         |
+| `.warn()`         | Set log level to warn                         |
+| `.error()`        | Set log level to error (captures stack)       |
+| `.trace()`        | Attach full stack trace                       |
+| `.table(cols?)`   | Format as table, optional column filter       |
+
+### `gg.time(label?)` -- Returns `GgTimerChain`
+
+| Method       | Description                               |
+| ------------ | ----------------------------------------- |
+| `.ns(label)` | Set namespace for timer group (inherited) |
+
+### `gg.timeLog(label?, ...args)` -- Log elapsed without stopping
+
+### `gg.timeEnd(label?)` -- Log elapsed and stop timer
+
+### `gg.here()` -- Returns `{ fileName, functionName, url }`
+
+### Control
+
+| Method              | Description                               |
+| ------------------- | ----------------------------------------- |
+| `gg.enable(ns)`     | Enable debug output for namespace pattern |
+| `gg.disable()`      | Disable all debug output                  |
+| `gg.clearPersist()` | Clear `gg-enabled` from localStorage      |
+
 ## Technical Details
 
 ### Internal Debug Implementation
@@ -248,6 +453,20 @@ Features implemented internally (~290 lines of TypeScript):
 
 This approach eliminates the need for vendoring, patching, and bundling third-party code, resulting in better type safety and simpler maintenance.
 
+### Microtask Auto-Flush
+
+When you call `gg(value)`, the log is **deferred to the next microtask**. This means chain modifiers (`.ns()`, `.warn()`, etc.) can be added synchronously after the call. If you need the value immediately (passthrough), use `.v` which forces an immediate flush.
+
+```javascript
+// These two are equivalent:
+gg('hello').warn(); // .warn() runs sync, log flushes on microtask
+gg('hello').warn().v; // .v forces immediate flush + returns 'hello'
+
+// Auto-flush means order doesn't matter for modifiers:
+gg('x').ns('foo').warn(); // same as:
+gg('x').warn().ns('foo'); // (both set ns and level before flush)
+```
+
 ## Inspirations
 
 ### debug

package/dist/gg-call-sites-plugin.d.ts

@@ -90,16 +90,19 @@ export declare function findEnclosingFunctionFromScopes(pos: number, scopes: Fun
  */
 export declare function escapeForString(s: string): string;
 /**
- * Transform gg() and gg.ns() calls in source code to gg._ns({ns, file, line, col, src}, ...) calls.
+ * Transform gg() calls in source code to inject call-site metadata.
  *
  * Handles:
  * - bare gg(expr) → gg._ns({ns, file, line, col, src: 'expr'}, expr)
- * - gg.ns('label', expr) → gg._ns({ns, file, line, col, src: 'expr'}, expr)
- *   - label supports template variables: $NS, $FN, $FILE, $LINE, $COL
- *   - plain label (no variables) is used as-is (no auto @fn append)
- * - gg.enable, gg.disable, gg.clearPersist, gg._onLog, gg._ns → left untouched
+ * - gg.here() → gg._here({ns, file, line, col})
+ * - gg.time/timeLog/timeEnd → gg._time/_timeLog/_timeEnd with metadata
+ * - gg.enable, gg.disable, gg.clearPersist, gg._ns, gg._onLog → left untouched
  * - gg inside strings and comments → left untouched
  *
+ * Chain methods (.ns(), .warn(), .error(), etc.) are NOT rewritten —
+ * they run at runtime and resolve template variables from the metadata
+ * that the plugin baked into the gg._ns() options object.
+ *
  * For .svelte files, `svelteInfo` (from `collectCodeRanges()`) determines which
  * positions contain JS code and provides AST-based function scope detection.
  * Script ranges use `{...}` object literal syntax; template ranges use `gg._o()`

package/dist/gg-call-sites-plugin.js

@@ -47,13 +47,7 @@ export default function ggCallSitesPlugin(options = {}) {
                 return null;
             // Quick bail: no gg calls in this file
             if (!code.includes('gg(') &&
-                !code.includes('gg.ns(') &&
-                !code.includes('gg.info(') &&
-                !code.includes('gg.warn(') &&
-                !code.includes('gg.error(') &&
-                !code.includes('gg.table(') &&
-                !code.includes('gg.trace(') &&
-                !code.includes('gg.assert(') &&
+                !code.includes('gg.here(') &&
                 !code.includes('gg.time(') &&
                 !code.includes('gg.timeLog(') &&
                 !code.includes('gg.timeEnd('))
@@ -590,16 +584,19 @@ export function escapeForString(s) {
     return s.replace(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/\n/g, '\\n').replace(/\r/g, '\\r');
 }
 /**
- * Transform gg() and gg.ns() calls in source code to gg._ns({ns, file, line, col, src}, ...) calls.
+ * Transform gg() calls in source code to inject call-site metadata.
  *
  * Handles:
  * - bare gg(expr) → gg._ns({ns, file, line, col, src: 'expr'}, expr)
- * - gg.ns('label', expr) → gg._ns({ns, file, line, col, src: 'expr'}, expr)
- *   - label supports template variables: $NS, $FN, $FILE, $LINE, $COL
- *   - plain label (no variables) is used as-is (no auto @fn append)
- * - gg.enable, gg.disable, gg.clearPersist, gg._onLog, gg._ns → left untouched
+ * - gg.here() → gg._here({ns, file, line, col})
+ * - gg.time/timeLog/timeEnd → gg._time/_timeLog/_timeEnd with metadata
+ * - gg.enable, gg.disable, gg.clearPersist, gg._ns, gg._onLog → left untouched
  * - gg inside strings and comments → left untouched
  *
+ * Chain methods (.ns(), .warn(), .error(), etc.) are NOT rewritten —
+ * they run at runtime and resolve template variables from the metadata
+ * that the plugin baked into the gg._ns() options object.
+ *
  * For .svelte files, `svelteInfo` (from `collectCodeRanges()`) determines which
  * positions contain JS code and provides AST-based function scope detection.
  * Script ranges use `{...}` object literal syntax; template ranges use `gg._o()`
@@ -720,7 +717,7 @@ export function transformGgCalls(code, shortPath, filePath, svelteInfo, jsFuncti
                 continue;
             }
         }
-        // Look for 'gg' pattern — could be gg( or gg.ns(
+        // Look for 'gg' pattern — could be gg( or gg.here( or gg.time(
         if (code[i] === 'g' && code[i + 1] === 'g') {
             // In .svelte files, skip gg outside code ranges (prose text, etc.)
             const range = rangeAt(i);
@@ -734,83 +731,22 @@ export function transformGgCalls(code, shortPath, filePath, svelteInfo, jsFuncti
                 i++;
                 continue;
             }
-            // Case 1: gg.ns('label', ...) → gg._ns({ns: 'label', file, line, col, src}, ...)
-            if (code.slice(i + 2, i + 6) === '.ns(') {
+            // Case 1: gg.here() → gg._here({ns, file, line, col})
+            if (code.slice(i + 2, i + 9) === '.here()') {
                 const { line, col } = getLineCol(code, i);
                 const fnName = getFunctionName(i, range);
-                const openParenPos = i + 5; // position of '(' in 'gg.ns('
-                // Find matching closing paren for the entire gg.ns(...) call
-                const closeParenPos = findMatchingParen(code, openParenPos);
-                if (closeParenPos === -1) {
-                    i += 6;
-                    continue;
-                }
-                // Extract the first argument (the namespace string)
-                // Look for the string literal after 'gg.ns('
-                let afterNsParen = i + 6; // position after 'gg.ns('
-                while (afterNsParen < code.length && /\s/.test(code[afterNsParen]))
-                    afterNsParen++;
-                const quoteChar = code[afterNsParen];
-                if (quoteChar === "'" || quoteChar === '"') {
-                    // Find the closing quote
-                    let j = afterNsParen + 1;
-                    while (j < code.length && code[j] !== quoteChar) {
-                        if (code[j] === '\\')
-                            j++; // skip escaped chars
-                        j++;
-                    }
-                    // j now points to closing quote
-                    const nsLabelRaw = code.slice(afterNsParen + 1, j);
-                    // Build callpoint: substitute $NS/$FN/$FILE/$LINE/$COL template variables.
-                    // The auto-generated callpoint (file@fn) is what bare gg() would produce.
-                    const autoCallpoint = `${shortPath}${fnName ? `@${fnName}` : ''}`;
-                    const callpoint = escapeForString(nsLabelRaw
-                        .replace(/\$NS/g, autoCallpoint)
-                        .replace(/\$FN/g, fnName)
-                        .replace(/\$FILE/g, shortPath)
-                        .replace(/\$LINE/g, String(line))
-                        .replace(/\$COL/g, String(col)));
-                    // Check if there are more args after the string
-                    const afterClosingQuote = j + 1;
-                    let k = afterClosingQuote;
-                    while (k < code.length && /\s/.test(code[k]))
-                        k++;
-                    if (code[k] === ')') {
-                        // gg.ns('label') → gg._ns(opts)
-                        result.push(code.slice(lastIndex, i));
-                        result.push(`gg._ns(${buildOptions(range, callpoint, line, col)})`);
-                        lastIndex = k + 1;
-                        i = k + 1;
-                    }
-                    else if (code[k] === ',') {
-                        // gg.ns('label', args...) → gg._ns(opts, args...)
-                        let argsStart = k + 1;
-                        while (argsStart < closeParenPos && /\s/.test(code[argsStart]))
-                            argsStart++;
-                        const argsSrc = code.slice(argsStart, closeParenPos).trim();
-                        const escapedSrc = escapeForString(argsSrc);
-                        result.push(code.slice(lastIndex, i));
-                        result.push(`gg._ns(${buildOptions(range, callpoint, line, col, escapedSrc)}, `);
-                        lastIndex = k + 1; // skip past the comma, keep args as-is
-                        i = k + 1;
-                    }
-                    else {
-                        // Unexpected — leave untouched
-                        i += 6;
-                        continue;
-                    }
-                    modified = true;
-                    continue;
-                }
-                // Non-string first arg to gg.ns — skip (can't extract ns at build time)
-                i += 6;
+                const callpoint = `${shortPath}${fnName ? `@${fnName}` : ''}`;
+                const escapedNs = escapeForString(callpoint);
+                result.push(code.slice(lastIndex, i));
+                result.push(`gg._here(${buildOptions(range, escapedNs, line, col)})`);
+                lastIndex = i + 9; // skip past 'gg.here()'
+                i = lastIndex;
+                modified = true;
                 continue;
             }
-            // Case 1b: gg.info/warn/error/table/trace/assert → gg._info/_warn/_error/_table/_trace/_assert
-            // These methods are rewritten like bare gg() but with their internal variant.
-            const dotMethodMatch = code
-                .slice(i + 2)
-                .match(/^\.(info|warn|error|table|trace|assert|time|timeLog|timeEnd)\(/);
+            // Case 2: gg.time/timeLog/timeEnd → gg._time/_timeLog/_timeEnd
+            // Timer methods are rewritten to inject call-site metadata.
+            const dotMethodMatch = code.slice(i + 2).match(/^\.(time|timeLog|timeEnd)\(/);
             if (dotMethodMatch) {
                 const methodName = dotMethodMatch[1];
                 const internalName = `_${methodName}`;
@@ -828,13 +764,13 @@ export function transformGgCalls(code, shortPath, filePath, svelteInfo, jsFuncti
                 const argsText = code.slice(openParenPos + 1, closeParenPos).trim();
                 result.push(code.slice(lastIndex, i));
                 if (argsText === '') {
-                    // gg.warn() → gg._warn(opts)
+                    // gg.time() → gg._time(opts)
                     result.push(`gg.${internalName}(${buildOptions(range, escapedNs, line, col)})`);
                     lastIndex = closeParenPos + 1;
                     i = closeParenPos + 1;
                 }
                 else {
-                    // gg.warn(expr) → gg._warn(opts, expr)
+                    // gg.time('label') → gg._time(opts, 'label')
                     const escapedSrc = escapeForString(argsText);
                     result.push(`gg.${internalName}(${buildOptions(range, escapedNs, line, col, escapedSrc)}, `);
                     lastIndex = openParenPos + 1; // keep original args
@@ -843,12 +779,12 @@ export function transformGgCalls(code, shortPath, filePath, svelteInfo, jsFuncti
                 modified = true;
                 continue;
             }
-            // Skip other gg.* calls (gg.enable, gg.disable, gg._ns, gg._onLog, gg.time, etc.)
+            // Skip other gg.* calls (gg.enable, gg.disable, gg._ns, gg._onLog, etc.)
             if (code[i + 2] === '.') {
                 i += 3;
                 continue;
             }
-            // Case 2: bare gg(...) → gg._ns({ns, file, line, col, src}, ...)
+            // Case 3: bare gg(...) → gg._ns({ns, file, line, col, src}, ...)
             if (code[i + 2] === '(') {
                 const { line, col } = getLineCol(code, i);
                 const fnName = getFunctionName(i, range);

package/dist/gg.d.ts

@@ -21,16 +21,91 @@ interface CapturedEntry {
     };
 }
 type OnLogCallback = (entry: CapturedEntry) => void;
-export declare function gg(): {
-    fileName: string;
-    functionName: string;
-    url: string;
-};
-export declare function gg<T>(arg: T, ...args: unknown[]): T;
-export declare namespace gg {
-    var disable: () => string;
-    var enable: (ns: string) => void;
-    var clearPersist: () => void;
+/**
+ * Log a value and return a chainable wrapper.
+ *
+ * Chain modifiers to configure the log entry:
+ * - `.ns('label')` — set a custom namespace
+ * - `.warn()` / `.error()` / `.info()` — set log level
+ * - `.trace()` — include stack trace
+ * - `.table()` — format as ASCII table
+ * - `.v` — flush immediately and return the passthrough value
+ *
+ * Without `.v`, the log auto-flushes on the next microtask.
+ *
+ * @example
+ * gg(value)                          // log with auto namespace
+ * gg(value).ns('label').warn()       // log with namespace + warn level
+ * const x = gg(value).v              // passthrough
+ * const x = gg(value).ns('foo').v    // passthrough with namespace
+ */
+export declare function gg<T>(arg: T, ...args: unknown[]): GgChain<T>;
+/** Internal options for the core log function */
+interface LogOptions {
+    ns: string;
+    file?: string;
+    line?: number;
+    col?: number;
+    src?: string;
+    level?: LogLevel;
+    stack?: string;
+    tableData?: {
+        keys: string[];
+        rows: Array<Record<string, unknown>>;
+    };
+}
+/**
+ * Chainable wrapper returned by gg(). Collects modifiers (.ns(), .warn(), etc.)
+ * and auto-flushes the log on the next microtask. Use `.v` to flush immediately
+ * and get the passthrough value.
+ *
+ * @example
+ * gg(value)                          // logs on microtask
+ * gg(value).ns('label').warn()       // logs with namespace + warn level
+ * const x = gg(value).v              // logs immediately, returns value
+ * const x = gg(value).ns('foo').v    // logs with namespace, returns value
+ */
+export declare class GgChain<T> {
+    #private;
+    constructor(value: T, args: unknown[], options: LogOptions, disabled?: boolean);
+    /** Set a custom namespace for this log entry.
+     *
+     * Supports template variables (resolved from plugin-provided metadata):
+     *   $NS   - auto-generated callpoint (file@fn with plugin, word-tuple without)
+     *   $FN   - enclosing function name (extracted from $NS)
+     *   $FILE - short file path (extracted from $NS)
+     *   $LINE - line number
+     *   $COL  - column number
+     */
+    ns(label: string): GgChain<T>;
+    /** Set log level to info (blue indicator). */
+    info(): GgChain<T>;
+    /** Set log level to warn (yellow indicator). */
+    warn(): GgChain<T>;
+    /** Set log level to error (red indicator, captures stack trace). */
+    error(): GgChain<T>;
+    /** Include a full stack trace with this log entry. */
+    trace(): GgChain<T>;
+    /** Format the log output as an ASCII table. */
+    table(columns?: string[]): GgChain<T>;
+    /** Flush the log immediately and return the passthrough value. */
+    get v(): T;
+}
+/**
+ * Chainable wrapper returned by gg.time(). Only supports .ns() for setting
+ * the namespace for the entire timer group (inherited by timeLog/timeEnd).
+ *
+ * @example
+ * gg.time('fetch').ns('api-pipeline')
+ * gg.time('fetch').ns('$FN:timers')    // template vars work too
+ */
+export declare class GgTimerChain {
+    #private;
+    constructor(label: string, options: LogOptions);
+    /** Set a custom namespace for this timer group.
+     * Supports the same template variables as GgChain.ns().
+     */
+    ns(label: string): GgTimerChain;
 }
 /**
  * ANSI Color Helpers for gg()
@@ -134,7 +209,6 @@ export declare function underline(): ChainableColorFn;
 export declare function dim(): ChainableColorFn;
 export declare namespace gg {
     let _onLog: OnLogCallback | null;
-    let ns: (nsLabel: string, ...args: unknown[]) => unknown;
     let _ns: (options: {
         ns: string;
         file?: string;
@@ -143,7 +217,7 @@ export declare namespace gg {
         src?: string;
         level?: LogLevel;
         stack?: string;
-    }, ...args: unknown[]) => unknown;
+    }, ...args: unknown[]) => GgChain<unknown>;
     let _o: (ns: string, file?: string, line?: number, col?: number, src?: string) => {
         ns: string;
         file?: string;
@@ -151,64 +225,34 @@ export declare namespace gg {
         col?: number;
         src?: string;
     };
-    let info: (...args: unknown[]) => unknown;
-    let warn: (...args: unknown[]) => unknown;
-    let error: (...args: unknown[]) => unknown;
-    let assert: (condition: unknown, ...args: unknown[]) => unknown;
-    let table: (data: unknown, columns?: string[]) => unknown;
-    let time: (label?: string) => void;
-    let timeLog: (label?: string, ...args: unknown[]) => void;
-    let timeEnd: (label?: string) => void;
-    let trace: (...args: unknown[]) => unknown;
-    let _info: (options: {
-        ns: string;
-        file?: string;
-        line?: number;
-        col?: number;
-        src?: string;
-    }, ...args: unknown[]) => unknown;
-    let _warn: (options: {
-        ns: string;
-        file?: string;
-        line?: number;
-        col?: number;
-        src?: string;
-    }, ...args: unknown[]) => unknown;
-    let _error: (options: {
-        ns: string;
-        file?: string;
-        line?: number;
-        col?: number;
-        src?: string;
-    }, ...args: unknown[]) => unknown;
-    let _assert: (options: {
-        ns: string;
-        file?: string;
-        line?: number;
-        col?: number;
-        src?: string;
-    }, condition: unknown, ...args: unknown[]) => unknown;
-    let _table: (options: {
-        ns: string;
-        file?: string;
-        line?: number;
-        col?: number;
-        src?: string;
-    }, data: unknown, columns?: string[]) => unknown;
-    let _trace: (options: {
+    let here: () => {
+        fileName: string;
+        functionName: string;
+        url: string;
+    };
+    let _here: (options: {
         ns: string;
         file?: string;
         line?: number;
         col?: number;
-        src?: string;
-    }, ...args: unknown[]) => unknown;
+    }) => {
+        fileName: string;
+        functionName: string;
+        url: string;
+    };
+    let enable: (ns: string) => void;
+    let disable: () => string;
+    let clearPersist: () => void;
+    let time: (label?: string) => GgTimerChain;
+    let timeLog: (label?: string, ...args: unknown[]) => void;
+    let timeEnd: (label?: string) => void;
     let _time: (options: {
         ns: string;
         file?: string;
         line?: number;
         col?: number;
         src?: string;
-    }, label?: string) => void;
+    }, label?: string) => GgTimerChain;
     let _timeLog: (options: {
         ns: string;
         file?: string;