@leftium/gg 0.0.41 → 0.0.42

package/dist/debug/index.d.ts

@@ -1,9 +1,25 @@
 /**
  * Debug entry point — selects browser or node implementation.
  *
+ * Uses a lazy initialization pattern to avoid top-level await,
+ * which has incomplete Safari support and breaks SSR-disabled pages.
+ * The debug factory is loaded on first use via a synchronous getter
+ * backed by a pre-started import promise.
+ *
  * Re-exports the DebugFactory and Debugger types for consumers.
  */
 import type { DebugFactory } from './common.js';
 export type { DebugFactory, Debugger } from './common.js';
-declare const _default: DebugFactory;
-export default _default;
+/**
+ * Promise that resolves when the debug factory is ready.
+ * Consumers that need to guarantee the factory is loaded can await this.
+ */
+export declare const debugReady: Promise<void>;
+/**
+ * Proxy-based default export that delegates to the real debug factory
+ * once loaded. This allows `import debug from './debug/index.js'` to
+ * work as a synchronous import while the actual implementation loads
+ * in the background.
+ */
+declare const debug: DebugFactory;
+export default debug;

package/dist/debug/index.js

@@ -1,11 +1,76 @@
 /**
  * Debug entry point — selects browser or node implementation.
  *
+ * Uses a lazy initialization pattern to avoid top-level await,
+ * which has incomplete Safari support and breaks SSR-disabled pages.
+ * The debug factory is loaded on first use via a synchronous getter
+ * backed by a pre-started import promise.
+ *
  * Re-exports the DebugFactory and Debugger types for consumers.
  */
 import { BROWSER } from 'esm-env';
-// Conditional import: browser.ts for browsers, node.ts for Node/Deno/Bun
-const { default: debug } = BROWSER
-    ? await import('./browser.js')
-    : await import('./node.js');
+// Start loading the platform-specific implementation immediately (non-blocking).
+// The promise begins resolving at module load time but doesn't block evaluation.
+let _debug = null;
+const _ready = (BROWSER ? import('./browser.js') : import('./node.js')).then((m) => {
+    _debug = m.default;
+});
+/**
+ * Ensure the debug factory is loaded. In practice, the dynamic import resolves
+ * almost instantly (it's a local module, not a network fetch), so by the time
+ * any consumer calls debugFactory() the promise is already settled.
+ *
+ * For the rare case where it's called before resolution, this returns a
+ * no-op debugger that buffers nothing — acceptable since gg diagnostics
+ * and early logging are already deferred in practice.
+ */
+function getDebugFactory() {
+    if (_debug)
+        return _debug;
+    // Fallback: return a minimal no-op factory while the real one loads.
+    // This path is hit only if someone calls debugFactory() synchronously
+    // during module evaluation, before the microtask resolves.
+    const noop = Object.assign(function noopDebug(_namespace) {
+        // Return a disabled debugger stub
+        const stub = Object.assign(function (..._args) { }, {
+            namespace: _namespace,
+            enabled: false,
+            color: '0',
+            diff: 0,
+            useColors: false,
+            log: () => { },
+            extend: (sub) => noopDebug(`${_namespace}:${sub}`),
+            destroy: () => stub,
+            formatArgs: undefined
+        });
+        return stub;
+    }, {
+        enable: (_namespaces) => { },
+        disable: () => '',
+        enabled: (_namespace) => false,
+        names: [],
+        skips: []
+    });
+    return noop;
+}
+/**
+ * Promise that resolves when the debug factory is ready.
+ * Consumers that need to guarantee the factory is loaded can await this.
+ */
+export const debugReady = _ready;
+/**
+ * Proxy-based default export that delegates to the real debug factory
+ * once loaded. This allows `import debug from './debug/index.js'` to
+ * work as a synchronous import while the actual implementation loads
+ * in the background.
+ */
+const debug = new Proxy((() => { }), {
+    apply(_target, _thisArg, args) {
+        return getDebugFactory()(args[0]);
+    },
+    get(_target, prop, _receiver) {
+        const factory = getDebugFactory();
+        return factory[prop];
+    }
+});
 export default debug;

package/dist/gg.d.ts

@@ -28,8 +28,8 @@ export declare function gg(): {
 };
 export declare function gg<T>(arg: T, ...args: unknown[]): T;
 export declare namespace gg {
-    var disable: () => void;
-    var enable: (namespaces: string) => void;
+    var disable: () => string;
+    var enable: (ns: string) => void;
     var clearPersist: () => void;
 }
 /**

package/dist/gg.js

@@ -39,19 +39,30 @@ const isCloudflareWorker = () => {
 if (isCloudflareWorker()) {
     console.warn('gg: CloudFlare not supported.');
 }
-// Try to load Node.js modules if not in CloudFlare Workers
+// Lazy-load Node.js modules to avoid top-level await (Safari compatibility).
+// The imports start immediately but don't block module evaluation.
 let dotenvModule = null;
 let httpModule = null;
-if (!isCloudflareWorker() && !BROWSER) {
-    try {
-        dotenvModule = await import('dotenv');
-    }
-    catch {
-        httpModule = await import('http');
-        // Failed to import Node.js modules
-        console.warn('gg: Node.js modules not available');
-    }
+function loadServerModules() {
+    if (isCloudflareWorker() || BROWSER)
+        return Promise.resolve();
+    return (async () => {
+        try {
+            dotenvModule = await import('dotenv');
+        }
+        catch {
+            // dotenv not available — optional dependency
+        }
+        try {
+            httpModule = await import('http');
+        }
+        catch {
+            console.warn('gg: Node.js http module not available');
+        }
+    })();
 }
+// Start loading immediately (non-blocking)
+const serverModulesReady = loadServerModules();
 function findAvailablePort(startingPort) {
     if (!httpModule)
         return Promise.resolve(startingPort);
@@ -80,15 +91,23 @@ function getServerPort() {
             resolve('5173');
         }
         else {
-            // Node.js environment
-            const startingPort = Number(process?.env?.PORT) || 5173; // Default to Vite's default port
-            findAvailablePort(startingPort).then((actualPort) => {
-                resolve(actualPort);
+            // Node.js environment — wait for http module to be available
+            serverModulesReady.then(() => {
+                const startingPort = Number(process?.env?.PORT) || 5173; // Default to Vite's default port
+                findAvailablePort(startingPort).then((actualPort) => {
+                    resolve(actualPort);
+                });
             });
         }
     });
 }
-const port = await getServerPort();
+// Port resolution starts immediately but doesn't block module evaluation.
+// The template is updated asynchronously once the port is known.
+let port = 5173; // Default fallback
+void getServerPort().then((p) => {
+    port = p;
+    ggConfig.openInEditorUrlTemplate = `http://localhost:${port}/__open-in-editor?file=$FILENAME`;
+});
 /**
  * Determines if gg should be enabled based on environment and runtime triggers.
  *
@@ -350,8 +369,8 @@ gg._ns = function (options, ...args) {
 gg._o = function (ns, file, line, col, src) {
     return { ns, file, line, col, src };
 };
-gg.disable = isCloudflareWorker() ? () => { } : debugFactory.disable;
-gg.enable = isCloudflareWorker() ? () => { } : debugFactory.enable;
+gg.disable = isCloudflareWorker() ? () => '' : () => debugFactory.disable();
+gg.enable = isCloudflareWorker() ? () => { } : (ns) => debugFactory.enable(ns);
 /**
  * Clear the persisted gg-enabled state from localStorage.
  * Useful to reset production trigger after testing with ?gg parameter.
@@ -956,6 +975,8 @@ export async function runGgDiagnostics() {
     if (!ggConfig.showHints || isCloudflareWorker() || diagnosticsRan)
         return;
     diagnosticsRan = true;
+    // Ensure server modules (dotenv) are loaded before diagnostics
+    await serverModulesReady;
     // Create test debugger for server-side enabled check
     const ggLogTest = debugFactory('gg:TEST');
     let ggMessage = '\n';

package/dist/vite.d.ts

@@ -21,8 +21,6 @@ export interface GgPluginsOptions {
  * Includes:
  * - `ggCallSitesPlugin` — rewrites `gg()` calls with source file/line/col metadata
  * - `openInEditorPlugin` — adds `/__open-in-editor` dev server middleware
- * - Automatic `es2022` build target (required for top-level await)
- *
  * @example
  * ```ts
  * import ggPlugins from '@leftium/gg/vite';

package/dist/vite.js

@@ -6,8 +6,6 @@ import openInEditorPlugin from './open-in-editor.js';
  * Includes:
  * - `ggCallSitesPlugin` — rewrites `gg()` calls with source file/line/col metadata
  * - `openInEditorPlugin` — adds `/__open-in-editor` dev server middleware
- * - Automatic `es2022` build target (required for top-level await)
- *
  * @example
  * ```ts
  * import ggPlugins from '@leftium/gg/vite';
@@ -19,23 +17,6 @@ import openInEditorPlugin from './open-in-editor.js';
  */
 export default function ggPlugins(options = {}) {
     const plugins = [];
-    // Ensure es2022 target for top-level await support
-    plugins.push({
-        name: 'gg-config',
-        config() {
-            return {
-                build: {
-                    target: 'es2022'
-                },
-                optimizeDeps: {
-                    esbuildOptions: {
-                        target: 'es2022',
-                        supported: { 'top-level-await': true }
-                    }
-                }
-            };
-        }
-    });
     plugins.push(ggCallSitesPlugin(options.callSites));
     if (options.openInEditor !== false) {
         plugins.push(openInEditorPlugin());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leftium/gg",
-  "version": "0.0.41",
+  "version": "0.0.42",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Leftium/gg.git"