@noego/wood 0.0.1

package/dist/main/index.d.cts

@@ -0,0 +1,98 @@
+import { Privileges, app, BrowserWindow, ipcMain, protocol, net, shell, screen } from 'electron';
+import { getLogger } from '@noego/logger';
+import { RegisterRuntimeRouter } from '../runtime/runtime.cjs';
+import { RendererLogCallback } from '../runtime/renderer_log_dispatcher.cjs';
+import '../router/wood_router.cjs';
+import '../types/operations.cjs';
+
+type CleanupHandler = () => void | Promise<void>;
+type WoodWindowConfig = {
+    title: string;
+    width: number;
+    height: number;
+    defaultRoute?: string;
+    frame?: boolean;
+    transparent?: boolean;
+    resizable?: boolean;
+    alwaysOnTop?: boolean;
+    minWidth?: number;
+    minHeight?: number;
+    maxWidth?: number;
+    maxHeight?: number;
+    show?: boolean;
+    parent?: string;
+    modal?: boolean;
+    vibrancy?: string;
+    backgroundMaterial?: string;
+    backgroundColor?: string;
+    rememberBounds?: boolean;
+    contextMenu?: 'native' | 'custom';
+};
+type PrivilegedSchemeRegistration = {
+    scheme: string;
+    privileges: Privileges;
+};
+interface WoodMainAppBootResult {
+    scope?: string;
+    configureContainer?: (container: any) => void;
+    registerSchemesAsPrivileged?: PrivilegedSchemeRegistration[];
+}
+interface WoodMainBootContext {
+    electron: {
+        app: typeof app;
+        BrowserWindow: typeof BrowserWindow;
+        ipcMain: typeof ipcMain;
+        protocol: typeof protocol;
+        net: typeof net;
+        shell: typeof shell;
+        screen: typeof screen;
+    };
+    logger: ReturnType<typeof getLogger>;
+}
+interface WoodMainRuntimeContext extends WoodMainBootContext {
+    container: any;
+    applicationRoot: string;
+    getWindow: (windowId: string) => BrowserWindow | null;
+    createWindow: (windowId?: string) => BrowserWindow;
+    navigateWindow: (windowId: string, route: string) => Promise<void>;
+    broadcast: (channel: string, data: unknown) => void;
+    setRendererLogCallback: (callback: RendererLogCallback | null) => void;
+    getRendererLogCallback: () => RendererLogCallback | null;
+    getDebugMetadata: () => WoodDebugMetadata;
+}
+interface StartWoodMainOptions {
+    registerRuntime: (router: RegisterRuntimeRouter) => void;
+    windowDefs: Record<string, WoodWindowConfig>;
+    controllersDir: string;
+    middlewareDir: string;
+    outDir?: string;
+    scope?: string;
+    configureContainer?: (container: any) => void;
+    appBoot?: (context: WoodMainBootContext) => void | WoodMainAppBootResult | Promise<void | WoodMainAppBootResult>;
+    mainBoot?: (appBootResult: unknown, context: WoodMainRuntimeContext) => void | CleanupHandler | Promise<void | CleanupHandler>;
+    onBeforeQuit?: (context: WoodMainRuntimeContext) => void | Promise<void>;
+    onLoad?: (data: unknown, event?: unknown) => Promise<unknown>;
+    onContextMenu?: (data: unknown, event?: unknown) => Promise<unknown>;
+}
+interface WoodDebugWindowMetadata {
+    windowId: string;
+    title: string;
+    webContentsId: number;
+    url: string;
+    focused: boolean;
+}
+interface WoodDebugMetadata {
+    ok: boolean;
+    enabled: boolean;
+    mode: 'development' | 'production';
+    port?: number;
+    windows: WoodDebugWindowMetadata[];
+}
+declare function resolveWoodDebugMetadataConfiguration(env?: NodeJS.ProcessEnv): {
+    enabled: boolean;
+    mode: 'development' | 'production';
+    port?: number;
+};
+declare function startWoodMain(options: StartWoodMainOptions): void;
+
+export { type PrivilegedSchemeRegistration, type StartWoodMainOptions, type WoodDebugMetadata, type WoodDebugWindowMetadata, type WoodMainAppBootResult, type WoodMainBootContext, type WoodMainRuntimeContext, type WoodWindowConfig, resolveWoodDebugMetadataConfiguration, startWoodMain };

package/dist/main/index.d.ts

@@ -0,0 +1,98 @@
+import { Privileges, app, BrowserWindow, ipcMain, protocol, net, shell, screen } from 'electron';
+import { getLogger } from '@noego/logger';
+import { RegisterRuntimeRouter } from '../runtime/runtime.js';
+import { RendererLogCallback } from '../runtime/renderer_log_dispatcher.js';
+import '../router/wood_router.js';
+import '../types/operations.js';
+
+type CleanupHandler = () => void | Promise<void>;
+type WoodWindowConfig = {
+    title: string;
+    width: number;
+    height: number;
+    defaultRoute?: string;
+    frame?: boolean;
+    transparent?: boolean;
+    resizable?: boolean;
+    alwaysOnTop?: boolean;
+    minWidth?: number;
+    minHeight?: number;
+    maxWidth?: number;
+    maxHeight?: number;
+    show?: boolean;
+    parent?: string;
+    modal?: boolean;
+    vibrancy?: string;
+    backgroundMaterial?: string;
+    backgroundColor?: string;
+    rememberBounds?: boolean;
+    contextMenu?: 'native' | 'custom';
+};
+type PrivilegedSchemeRegistration = {
+    scheme: string;
+    privileges: Privileges;
+};
+interface WoodMainAppBootResult {
+    scope?: string;
+    configureContainer?: (container: any) => void;
+    registerSchemesAsPrivileged?: PrivilegedSchemeRegistration[];
+}
+interface WoodMainBootContext {
+    electron: {
+        app: typeof app;
+        BrowserWindow: typeof BrowserWindow;
+        ipcMain: typeof ipcMain;
+        protocol: typeof protocol;
+        net: typeof net;
+        shell: typeof shell;
+        screen: typeof screen;
+    };
+    logger: ReturnType<typeof getLogger>;
+}
+interface WoodMainRuntimeContext extends WoodMainBootContext {
+    container: any;
+    applicationRoot: string;
+    getWindow: (windowId: string) => BrowserWindow | null;
+    createWindow: (windowId?: string) => BrowserWindow;
+    navigateWindow: (windowId: string, route: string) => Promise<void>;
+    broadcast: (channel: string, data: unknown) => void;
+    setRendererLogCallback: (callback: RendererLogCallback | null) => void;
+    getRendererLogCallback: () => RendererLogCallback | null;
+    getDebugMetadata: () => WoodDebugMetadata;
+}
+interface StartWoodMainOptions {
+    registerRuntime: (router: RegisterRuntimeRouter) => void;
+    windowDefs: Record<string, WoodWindowConfig>;
+    controllersDir: string;
+    middlewareDir: string;
+    outDir?: string;
+    scope?: string;
+    configureContainer?: (container: any) => void;
+    appBoot?: (context: WoodMainBootContext) => void | WoodMainAppBootResult | Promise<void | WoodMainAppBootResult>;
+    mainBoot?: (appBootResult: unknown, context: WoodMainRuntimeContext) => void | CleanupHandler | Promise<void | CleanupHandler>;
+    onBeforeQuit?: (context: WoodMainRuntimeContext) => void | Promise<void>;
+    onLoad?: (data: unknown, event?: unknown) => Promise<unknown>;
+    onContextMenu?: (data: unknown, event?: unknown) => Promise<unknown>;
+}
+interface WoodDebugWindowMetadata {
+    windowId: string;
+    title: string;
+    webContentsId: number;
+    url: string;
+    focused: boolean;
+}
+interface WoodDebugMetadata {
+    ok: boolean;
+    enabled: boolean;
+    mode: 'development' | 'production';
+    port?: number;
+    windows: WoodDebugWindowMetadata[];
+}
+declare function resolveWoodDebugMetadataConfiguration(env?: NodeJS.ProcessEnv): {
+    enabled: boolean;
+    mode: 'development' | 'production';
+    port?: number;
+};
+declare function startWoodMain(options: StartWoodMainOptions): void;
+
+export { type PrivilegedSchemeRegistration, type StartWoodMainOptions, type WoodDebugMetadata, type WoodDebugWindowMetadata, type WoodMainAppBootResult, type WoodMainBootContext, type WoodMainRuntimeContext, type WoodWindowConfig, resolveWoodDebugMetadataConfiguration, startWoodMain };

package/dist/main/index.js

@@ -0,0 +1,475 @@
+import path from "path";
+import {
+  app as electronApp,
+  BrowserWindow,
+  ipcMain,
+  protocol,
+  net,
+  shell,
+  screen
+} from "electron";
+import { getLogger } from "@noego/logger";
+import { WindowStateStore } from "../window/window_state_store.js";
+import { getContainer } from "../runtime/get_container.js";
+import { runtime as bootRuntime } from "../runtime/runtime.js";
+import { setApplicationRoot } from "../runtime/application_root.js";
+import {
+  getRendererLogDispatcher
+} from "../runtime/renderer_log_dispatcher.js";
+import { Ipc, getIpc } from "../ipc/index.js";
+import { setIpcPushSender, clearIpcPushSender } from "../ipc/shared.js";
+const DEFAULT_WOOD_REMOTE_DEBUGGING_PORT = 9333;
+function resolveWoodDebugMetadataConfiguration(env = process.env) {
+  const isDevelopment = env.WOOD_MODE === "development";
+  if (!isDevelopment) {
+    return {
+      enabled: false,
+      mode: "production"
+    };
+  }
+  const rawPort = env.WOOD_REMOTE_DEBUGGING_PORT;
+  const parsedPort = rawPort ? Number.parseInt(rawPort, 10) : DEFAULT_WOOD_REMOTE_DEBUGGING_PORT;
+  const port = Number.isFinite(parsedPort) && parsedPort > 0 ? parsedPort : DEFAULT_WOOD_REMOTE_DEBUGGING_PORT;
+  return {
+    enabled: true,
+    mode: "development",
+    port
+  };
+}
+function resolveWindowDef(windowDefs, windowId = "main") {
+  const def = windowDefs[windowId];
+  if (!def) {
+    throw new Error(`Window "${windowId}" not defined in generated window defs.`);
+  }
+  return def;
+}
+function resolveRuntimePath(relativeOrAbsolutePath) {
+  if (path.isAbsolute(relativeOrAbsolutePath)) {
+    return relativeOrAbsolutePath;
+  }
+  return path.join(electronApp.getAppPath(), relativeOrAbsolutePath);
+}
+function toErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function startWoodMain(options) {
+  const logger = getLogger("wood:main").named("bootstrap");
+  const runtimeLogger = getLogger("wood:main").named("runtime");
+  const debugConfig = resolveWoodDebugMetadataConfiguration();
+  const windowState = new WindowStateStore();
+  const windows = /* @__PURE__ */ new Map();
+  let mainWindow = null;
+  let runtimeContext = null;
+  let mainBootCleanup;
+  for (const stream of [process.stdout, process.stderr]) {
+    stream.on("error", (error) => {
+      if (error.code === "EPIPE") {
+        return;
+      }
+      throw error;
+    });
+  }
+  if (debugConfig.enabled && debugConfig.port) {
+    electronApp.commandLine.appendSwitch("remote-debugging-port", String(debugConfig.port));
+    electronApp.commandLine.appendSwitch("remote-debugging-address", "127.0.0.1");
+    logger.info("devtools remote debugging enabled", {
+      port: debugConfig.port,
+      mode: debugConfig.mode
+    });
+  }
+  const bootContext = {
+    electron: {
+      app: electronApp,
+      BrowserWindow,
+      ipcMain,
+      protocol,
+      net,
+      shell,
+      screen
+    },
+    logger
+  };
+  void (async () => {
+    const appBootResult = options.appBoot ? await options.appBoot(bootContext) : void 0;
+    const bootOverrides = appBootResult ?? {};
+    const scope = bootOverrides.scope ?? options.scope ?? process.cwd();
+    const configureContainer = bootOverrides.configureContainer ?? options.configureContainer;
+    const privilegedSchemes = Array.isArray(bootOverrides.registerSchemesAsPrivileged) ? bootOverrides.registerSchemesAsPrivileged : [];
+    if (privilegedSchemes.length > 0) {
+      protocol.registerSchemesAsPrivileged(privilegedSchemes);
+      logger.info("registered privileged schemes", {
+        count: privilegedSchemes.length,
+        schemes: privilegedSchemes.map((entry) => entry.scheme)
+      });
+    }
+    const outDir = options.outDir ?? "out";
+    const preloadPath = path.join(electronApp.getAppPath(), outDir, "preload", "index.js");
+    const rendererFile = path.join(electronApp.getAppPath(), outDir, "renderer", "index.html");
+    const container = getContainer({
+      scope,
+      ...configureContainer ? { configure: configureContainer } : {}
+    });
+    const registrationContainer = container;
+    if (typeof registrationContainer.registerFunction === "function") {
+      registrationContainer.registerFunction(Ipc, () => getIpc());
+    }
+    const getWindow = (windowId) => {
+      const existing = windows.get(windowId);
+      if (!existing) {
+        return null;
+      }
+      if (existing.isDestroyed()) {
+        windows.delete(windowId);
+        return null;
+      }
+      return existing;
+    };
+    const findWindowIdByWebContents = (webContentsId) => {
+      for (const [windowId, win] of windows.entries()) {
+        if (win.isDestroyed()) {
+          windows.delete(windowId);
+          continue;
+        }
+        if (win.webContents.id === webContentsId) {
+          return windowId;
+        }
+      }
+      return null;
+    };
+    const waitForWindowReady = async (win) => {
+      const webContents = win.webContents;
+      const isLoading = typeof webContents.isLoadingMainFrame === "function" ? webContents.isLoadingMainFrame() : webContents.isLoading();
+      if (!isLoading) {
+        return;
+      }
+      await new Promise((resolve) => {
+        webContents.once("did-finish-load", () => resolve());
+      });
+    };
+    const getDebugMetadata = () => {
+      const debugWindows = [];
+      for (const [windowId, win] of windows.entries()) {
+        if (win.isDestroyed()) {
+          windows.delete(windowId);
+          continue;
+        }
+        debugWindows.push({
+          windowId,
+          title: win.getTitle(),
+          webContentsId: win.webContents.id,
+          url: win.webContents.getURL(),
+          focused: win.isFocused()
+        });
+      }
+      return {
+        ok: true,
+        enabled: debugConfig.enabled,
+        mode: debugConfig.mode,
+        ...debugConfig.port ? { port: debugConfig.port } : {},
+        windows: debugWindows
+      };
+    };
+    const createWindow = (windowId = "main") => {
+      const existing = getWindow(windowId);
+      if (existing) {
+        existing.show();
+        existing.focus();
+        return existing;
+      }
+      const windowDef = resolveWindowDef(options.windowDefs, windowId);
+      const defaultShow = windowDef.show ?? true;
+      const parentWindow = windowDef.parent ? getWindow(windowDef.parent) : null;
+      windowState.setScreen(screen);
+      const savedBounds = windowDef.rememberBounds ? windowState.getBounds(windowId) : null;
+      const windowOptions = {
+        width: savedBounds?.width ?? windowDef.width,
+        height: savedBounds?.height ?? windowDef.height,
+        ...savedBounds ? { x: savedBounds.x, y: savedBounds.y } : {},
+        ...windowDef.minWidth != null ? { minWidth: windowDef.minWidth } : {},
+        ...windowDef.minHeight != null ? { minHeight: windowDef.minHeight } : {},
+        ...windowDef.maxWidth != null ? { maxWidth: windowDef.maxWidth } : {},
+        ...windowDef.maxHeight != null ? { maxHeight: windowDef.maxHeight } : {},
+        ...typeof windowDef.modal === "boolean" ? { modal: windowDef.modal } : {},
+        ...parentWindow ? { parent: parentWindow } : {},
+        title: windowDef.title,
+        frame: windowDef.frame ?? true,
+        transparent: windowDef.transparent ?? false,
+        resizable: windowDef.resizable ?? true,
+        alwaysOnTop: windowDef.alwaysOnTop ?? false,
+        ...typeof windowDef.backgroundColor === "string" ? { backgroundColor: windowDef.backgroundColor } : {},
+        ...process.platform === "darwin" && typeof windowDef.vibrancy === "string" ? {
+          vibrancy: windowDef.vibrancy,
+          visualEffectState: "active"
+        } : {},
+        ...process.platform === "win32" && typeof windowDef.backgroundMaterial === "string" ? {
+          backgroundMaterial: windowDef.backgroundMaterial
+        } : {},
+        show: savedBounds ? false : defaultShow,
+        webPreferences: {
+          preload: preloadPath,
+          contextIsolation: true,
+          nodeIntegration: false
+        }
+      };
+      const win = new BrowserWindow(windowOptions);
+      windows.set(windowId, win);
+      if (windowId === "main") {
+        mainWindow = win;
+      }
+      if (savedBounds?.isMaximized) {
+        win.maximize();
+      } else if (savedBounds?.isFullScreen) {
+        win.setFullScreen(true);
+      }
+      if (savedBounds && defaultShow) {
+        win.show();
+      }
+      if (windowDef.rememberBounds) {
+        const captureNormalBounds = () => {
+          if (!win.isMaximized() && !win.isFullScreen()) {
+            const rect = win.getBounds();
+            windowState.updateBoundsDebounced(windowId, {
+              ...rect,
+              isMaximized: false,
+              isFullScreen: false
+            });
+          }
+        };
+        win.on("move", captureNormalBounds);
+        win.on("resize", captureNormalBounds);
+        win.on("close", () => {
+          const rect = win.getBounds();
+          windowState.saveBoundsSync(windowId, {
+            ...rect,
+            isMaximized: win.isMaximized(),
+            isFullScreen: win.isFullScreen()
+          });
+        });
+      }
+      win.webContents.setWindowOpenHandler(({ url }) => {
+        if (url.startsWith("http://") || url.startsWith("https://")) {
+          void shell.openExternal(url);
+        }
+        return { action: "deny" };
+      });
+      win.webContents.on("will-navigate", (event, url) => {
+        if (process.env.ELECTRON_RENDERER_URL && url.startsWith(process.env.ELECTRON_RENDERER_URL)) {
+          return;
+        }
+        if (url.startsWith("http://") || url.startsWith("https://")) {
+          event.preventDefault();
+          void shell.openExternal(url);
+        }
+      });
+      const rendererLogger = getLogger("wood:main").named(`renderer:${windowId}`);
+      const levelMap = {
+        0: "debug",
+        1: "info",
+        2: "warn",
+        3: "error"
+      };
+      win.webContents.on("console-message", (_event, level, message, line, sourceId) => {
+        const method = levelMap[level] ?? "info";
+        rendererLogger[method](message, { source: sourceId, line, windowId });
+      });
+      if (process.env.ELECTRON_RENDERER_URL) {
+        void win.loadURL(process.env.ELECTRON_RENDERER_URL);
+      } else {
+        void win.loadFile(rendererFile);
+      }
+      win.on("closed", () => {
+        windows.delete(windowId);
+        if (windowId === "main") {
+          mainWindow = null;
+        }
+      });
+      logger.info("window created", { windowId });
+      return win;
+    };
+    const navigateWindow = async (windowId, route) => {
+      const win = createWindow(windowId);
+      await waitForWindowReady(win);
+      win.webContents.send("__event:__navigate", { route });
+      win.show();
+      win.focus();
+    };
+    const dispatchPushEvent = (channel, data, options2) => {
+      const eventChannel = channel.startsWith("__event:") ? channel : `__event:${channel}`;
+      if (options2?.windowId) {
+        const target = getWindow(options2.windowId);
+        if (target && !target.isDestroyed()) {
+          target.webContents.send(eventChannel, data);
+        }
+        return;
+      }
+      for (const [windowId, win] of windows.entries()) {
+        if (win.isDestroyed()) {
+          windows.delete(windowId);
+          continue;
+        }
+        win.webContents.send(eventChannel, data);
+      }
+    };
+    setIpcPushSender(dispatchPushEvent);
+    const broadcast = (channel, data) => {
+      for (const [windowId, win] of windows.entries()) {
+        if (win.isDestroyed()) {
+          windows.delete(windowId);
+          continue;
+        }
+        win.webContents.send(channel, data);
+      }
+    };
+    runtimeContext = {
+      ...bootContext,
+      container,
+      applicationRoot: "",
+      getWindow,
+      createWindow,
+      navigateWindow,
+      broadcast,
+      setRendererLogCallback: (callback) => {
+        getRendererLogDispatcher().setCallback(callback);
+      },
+      getRendererLogCallback: () => getRendererLogDispatcher().getCallback(),
+      getDebugMetadata
+    };
+    const bootstrap = async () => {
+      logger.info("bootstrap starting");
+      const applicationRoot = setApplicationRoot(path.join(electronApp.getPath("userData"), "wood"));
+      runtimeContext.applicationRoot = applicationRoot;
+      logger.info("application root configured", { applicationRoot });
+      if (options.mainBoot) {
+        const bootResult = await options.mainBoot(appBootResult, runtimeContext);
+        if (typeof bootResult === "function") {
+          mainBootCleanup = bootResult;
+        }
+      }
+      await bootRuntime({
+        container,
+        ipcMain,
+        registerRuntime: options.registerRuntime,
+        controllersDir: resolveRuntimePath(options.controllersDir),
+        middlewareDir: resolveRuntimePath(options.middlewareDir),
+        onLoad: options.onLoad ?? (async () => {
+          throw new Error('Reserved channel "__load" is not configured for this app.');
+        }),
+        onNavigate: async (rawData) => {
+          const data = rawData;
+          if (!data.windowId) {
+            throw new Error("__navigate requires windowId");
+          }
+          if (!data.route) {
+            throw new Error("__navigate requires route");
+          }
+          await navigateWindow(data.windowId, data.route);
+          return { ok: true };
+        },
+        onWindow: async (rawData, event) => {
+          const data = rawData;
+          const action = data.action ?? "";
+          const windowId = data.windowId;
+          if (action === "current") {
+            const ipcEvent = event;
+            const senderWindowId = ipcEvent?.sender ? findWindowIdByWebContents(ipcEvent.sender.id) : null;
+            if (!senderWindowId) {
+              return { ok: false };
+            }
+            const senderWindowDef = resolveWindowDef(options.windowDefs, senderWindowId);
+            return {
+              ok: true,
+              windowId: senderWindowId,
+              defaultRoute: senderWindowDef.defaultRoute
+            };
+          }
+          if (action === "open") {
+            if (!windowId) {
+              throw new Error("__window.open requires windowId");
+            }
+            createWindow(windowId);
+            return { ok: true };
+          }
+          const win = windowId ? getWindow(windowId) : mainWindow;
+          if (!win) {
+            return { ok: false };
+          }
+          switch (action) {
+            case "close":
+              win.close();
+              return { ok: true };
+            case "focus":
+              win.show();
+              win.focus();
+              return { ok: true };
+            case "minimize":
+              win.minimize();
+              return { ok: true };
+            case "maximize":
+              win.isMaximized() ? win.unmaximize() : win.maximize();
+              return { ok: true };
+            default:
+              return { ok: false };
+          }
+        },
+        onDebug: async (rawData) => {
+          const data = rawData;
+          const action = data?.action ?? "";
+          if (action === "current") {
+            return getDebugMetadata();
+          }
+          return { ok: false };
+        },
+        onContextMenu: options.onContextMenu ?? (async (_rawData, event) => {
+          const ipcEvent = event;
+          const senderId = ipcEvent?.sender?.id;
+          runtimeLogger.debug("context menu requested", { senderId });
+          return { ok: true };
+        })
+      });
+      createWindow("main");
+      logger.info("bootstrap complete");
+    };
+    void electronApp.whenReady().then(bootstrap).catch((error) => {
+      logger.error("bootstrap failed", {
+        message: toErrorMessage(error),
+        stack: error instanceof Error ? error.stack : void 0
+      });
+    });
+    electronApp.on("before-quit", () => {
+      if (!runtimeContext) {
+        return;
+      }
+      void (async () => {
+        try {
+          clearIpcPushSender();
+          if (mainBootCleanup) {
+            await mainBootCleanup();
+          }
+          if (options.onBeforeQuit) {
+            await options.onBeforeQuit(runtimeContext);
+          }
+        } catch (error) {
+          logger.warn("before-quit handler failed", { error: toErrorMessage(error) });
+        }
+      })();
+    });
+    electronApp.on("window-all-closed", () => {
+      electronApp.quit();
+    });
+    electronApp.on("activate", () => {
+      if (BrowserWindow.getAllWindows().length === 0) {
+        createWindow("main");
+      }
+    });
+  })().catch((error) => {
+    logger.error("startup failed before ready", {
+      message: toErrorMessage(error),
+      stack: error instanceof Error ? error.stack : void 0
+    });
+  });
+}
+export {
+  resolveWoodDebugMetadataConfiguration,
+  startWoodMain
+};
+//# sourceMappingURL=index.js.map