@arcanewizards/sigil 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,134 @@
+import * as react from 'react';
+import { JSX, ReactNode, FC } from 'react';
+import { Logger } from '@arcanejs/protocol/logging';
+import { ToolkitRenderer } from '@arcanejs/react-toolkit';
+import { Toolkit, ToolkitOptions, ToolkitRenderContext } from '@arcanejs/toolkit';
+import { EventEmitter } from 'node:events';
+import pino from 'pino';
+import { A as AppRootLogEntry, S as SystemInformation } from './types-X8O95zmC.js';
+export { a as AppRootLogEntryStackFrame } from './types-X8O95zmC.js';
+import { AnyClientComponentCall } from '@arcanejs/protocol';
+import { BaseParent, AnyComponent } from '@arcanejs/toolkit/components/base';
+import { IDMap } from '@arcanejs/toolkit/util';
+import { g as SigilNamespace, S as SigilAppRootComponent, a as AppRootGetLogsArgs, b as AppRootGetLogsReturn, e as SigilComponentCalls } from './proto-kGDF-yWB.js';
+export { A as AppRootGetLogs, c as SIGIL_NAMESPACE, d as SigilComponent, h as SigilComponentMessage, i as isSigilComponent, f as isSigilComponentCall } from './proto-kGDF-yWB.js';
+import { NetworkPortStatus } from '@arcanewizards/net-utils';
+import '@arcanejs/diff';
+
+type AppInformationContextData = {
+    version: string;
+    title: string;
+};
+declare const AppInformationContext: react.Context<AppInformationContextData>;
+type ShutdownContextData = {
+    addShutdownListener: (listener: () => Promise<void>) => void;
+    removeShutdownListener: (listener: () => Promise<void>) => void;
+};
+declare const ShutdownContext: react.Context<ShutdownContextData>;
+declare const useShutdownHandler: (handler: () => Promise<void>) => void;
+declare const LoggerContext: react.Context<{
+    logger: Logger;
+}>;
+declare const useLogger: () => Logger;
+
+type SigilLogEventEmitter = EventEmitter<{
+    logsUpdated: [{
+        logs: AppRootLogEntry[];
+    }];
+}>;
+type SigilRuntimeAppProps<TAppApi, TExtraAppProps extends object> = TExtraAppProps & {
+    title: string;
+    version: string;
+    toolkit: Toolkit;
+    logger: Logger;
+    logEventEmitter: SigilLogEventEmitter;
+    setAppApi: (api: TAppApi | null) => void;
+    setWindowUrl: (windowUrl: URL) => void;
+    shutdownContext: ShutdownContextData;
+};
+type SigilRuntimeEventMap<TAppApi> = {
+    apiChange: (api: TAppApi | null) => void;
+    windowUrlChange: (url: URL) => void;
+};
+type SigilAppInstance<TAppApi> = {
+    addEventListener<K extends keyof SigilRuntimeEventMap<TAppApi>>(event: K, listener: SigilRuntimeEventMap<TAppApi>[K]): void;
+    shutdown: () => Promise<void>;
+};
+type SigilRuntimeOptions<TAppApi, TExtraAppProps extends object> = {
+    logger: pino.Logger;
+    title: string;
+    version: string;
+    appProps: TExtraAppProps;
+    toolkitOptions?: Omit<Partial<ToolkitOptions>, 'logger'>;
+    createApp: (props: SigilRuntimeAppProps<TAppApi, TExtraAppProps>) => JSX.Element;
+    componentNamespaces?: NonNullable<Parameters<typeof ToolkitRenderer.render>[3]>['componentNamespaces'];
+};
+declare const createSystemInformation: ({ dataDirectory, version, }: {
+    dataDirectory: string;
+    version: string;
+}) => SystemInformation;
+declare const runSigilApp: <TAppApi, TExtraAppProps extends object>({ logger: upstreamLogger, title, version, appProps, toolkitOptions, createApp, componentNamespaces, }: SigilRuntimeOptions<TAppApi, TExtraAppProps>) => SigilAppInstance<TAppApi>;
+
+type AppShellProps = {
+    title: string;
+    version: string;
+    dataDirectory: string;
+    logger: Logger;
+    logEventEmitter: SigilLogEventEmitter;
+    shutdownContext: ShutdownContextData;
+    children: ReactNode;
+};
+declare const AppShell: ({ title, version, dataDirectory, logger, logEventEmitter, shutdownContext, children, }: AppShellProps) => JSX.Element;
+
+type AppRootEvents = {
+    getLogs: (args: AppRootGetLogsArgs) => Promise<AppRootGetLogsReturn>;
+};
+type AppRootProps = Pick<SigilAppRootComponent, 'lastLog' | 'system'> & {
+    onGetLogs?: AppRootEvents['getLogs'];
+};
+type SupportedCalls = 'app-root-get-logs';
+declare class AppRoot extends BaseParent<SigilNamespace, SigilAppRootComponent, AppRootProps, SigilComponentCalls, SupportedCalls> {
+    private readonly events;
+    constructor(props: AppRootProps);
+    addListener: <T extends "getLogs">(type: T, listener: AppRootEvents[T]) => void;
+    removeListener: <T extends "getLogs">(type: T, listener: AppRootEvents[T]) => void;
+    validateChildren: (children: AnyComponent[]) => void;
+    getProtoInfo(idMap: IDMap, context: ToolkitRenderContext): SigilAppRootComponent;
+    handleCall: (call: AnyClientComponentCall) => Promise<AppRootGetLogsReturn>;
+}
+declare const SIGIL_COMPONENTS: {
+    _namespace: string;
+    _creators: {
+        AppRoot: (props: {
+            [key: string]: any;
+        }) => AnyComponent;
+    };
+} & {
+    AppRoot: react.ForwardRefExoticComponent<Pick<SigilAppRootComponent, "lastLog" | "system"> & {
+        onGetLogs?: AppRootEvents["getLogs"];
+    } & {
+        children?: react.ReactNode;
+    } & react.RefAttributes<AppRoot>>;
+};
+
+type ListenerConfig = {
+    port: number | {
+        from: number;
+        to: number;
+    };
+    interface?: string | undefined;
+};
+type AllListenerConfig = Record<string, ListenerConfig>;
+type AppListenerManagerAppRegistration = {
+    removeConnection: (uuid: string) => void;
+    setConnection: (uuid: string, details: NetworkPortStatus) => void;
+};
+type AppListenerManagerProps = {
+    appRegistration?: AppListenerManagerAppRegistration;
+    listenerConfig: AllListenerConfig;
+    toolkit: Toolkit;
+    setWindowUrl: (windowUrl: URL) => void;
+};
+declare const AppListenerManager: FC<AppListenerManagerProps>;
+
+export { type AllListenerConfig, AppInformationContext, type AppInformationContextData, AppListenerManager, type AppListenerManagerAppRegistration, AppRoot, AppRootGetLogsArgs, AppRootGetLogsReturn, AppRootLogEntry, AppShell, type AppShellProps, type ListenerConfig, LoggerContext, SIGIL_COMPONENTS, ShutdownContext, type ShutdownContextData, type SigilAppInstance, SigilAppRootComponent, SigilComponentCalls, type SigilRuntimeAppProps, type SigilRuntimeEventMap, type SigilRuntimeOptions, SystemInformation, createSystemInformation, runSigilApp, useLogger, useShutdownHandler };

package/dist/index.js

@@ -0,0 +1,492 @@
+import {
+  SIGIL_NAMESPACE,
+  isSigilComponent,
+  isSigilComponentCall
+} from "./chunk-LSHKAVON.js";
+
+// src/app-shell.tsx
+import { useEffect as useEffect2, useMemo, useState } from "react";
+
+// src/backend/app-root.ts
+import {
+  BaseParent,
+  EventEmitter
+} from "@arcanejs/toolkit/components/base";
+import { prepareComponents } from "@arcanejs/react-toolkit";
+var DEFAULT_PROPS = {
+  lastLog: -1,
+  system: {
+    version: "unknown",
+    appPath: "unknown",
+    cwd: "unknown",
+    os: "unknown",
+    dataDirectory: "unknown"
+  }
+};
+var AppRoot = class extends BaseParent {
+  events = new EventEmitter();
+  constructor(props) {
+    super(DEFAULT_PROPS, props, {
+      onPropsUpdated: (oldProps) => this.events.processPropChanges(
+        {
+          onGetLogs: "getLogs"
+        },
+        oldProps,
+        this.props
+      )
+    });
+    this.triggerInitialPropsUpdate();
+  }
+  addListener = this.events.addListener;
+  removeListener = this.events.removeListener;
+  validateChildren = (children) => {
+    if (children.length > 1) {
+      throw new Error("Sigil AppRoot can only have one child");
+    }
+  };
+  getProtoInfo(idMap, context) {
+    return {
+      namespace: SIGIL_NAMESPACE,
+      component: "app-root",
+      key: idMap.getId(this),
+      child: this.getChildren().slice(0, 1).map((child) => child.getProtoInfo(idMap, context))[0] ?? null,
+      lastLog: this.props.lastLog,
+      system: this.props.system
+    };
+  }
+  handleCall = async (call) => {
+    if (isSigilComponentCall(call, "app-root-get-logs")) {
+      return this.events.call("getLogs", { after: call.after });
+    }
+    throw new Error(`Unhandled call action: ${call.action}`);
+  };
+};
+var SIGIL_COMPONENTS = prepareComponents(SIGIL_NAMESPACE, {
+  AppRoot
+});
+
+// src/context.tsx
+import { createContext, useContext, useEffect } from "react";
+var AppInformationContext = createContext({
+  version: "",
+  title: ""
+});
+var ShutdownContext = createContext(
+  new Proxy({}, {
+    get() {
+      throw new Error(
+        "ShutdownContext is not available outside of the Sigil application environment"
+      );
+    }
+  })
+);
+var useShutdownHandler = (handler) => {
+  const { addShutdownListener, removeShutdownListener } = useContext(ShutdownContext);
+  useEffect(() => {
+    addShutdownListener(handler);
+    return () => {
+      removeShutdownListener(handler);
+    };
+  }, [addShutdownListener, removeShutdownListener, handler]);
+};
+var LoggerContext = createContext({
+  get logger() {
+    throw new Error("Logger not initialized");
+  }
+});
+var useLogger = () => {
+  return useContext(LoggerContext).logger;
+};
+
+// src/runtime.tsx
+import { ArcaneDataFileError } from "@arcanejs/react-toolkit/data";
+import { CoreComponents, ToolkitRenderer } from "@arcanejs/react-toolkit";
+import { Toolkit } from "@arcanejs/toolkit";
+import { EventEmitter as EventEmitter2 } from "events";
+var MAX_LOG_ENTRIES = 1e3;
+var getStackFramesFromError = (error) => {
+  if (typeof error === "string") {
+    return { message: error, stack: null, cause: null };
+  }
+  if (!(error instanceof Error)) {
+    return { message: String(error), stack: null, cause: null };
+  }
+  const frame = {
+    message: error.message,
+    stack: error.stack ?? null,
+    cause: error.cause ? getStackFramesFromError(error.cause) : null
+  };
+  if (error instanceof ArcaneDataFileError) {
+    frame.filePath = error.path;
+    frame.operation = error.operation;
+    frame.contents = error.contents;
+  }
+  return frame;
+};
+var createSystemInformation = ({
+  dataDirectory,
+  version
+}) => {
+  return {
+    appPath: process.execPath,
+    cwd: process.cwd(),
+    os: process.platform,
+    version,
+    dataDirectory
+  };
+};
+var runSigilApp = ({
+  logger: upstreamLogger,
+  title,
+  version,
+  appProps,
+  toolkitOptions,
+  createApp,
+  componentNamespaces = [CoreComponents, SIGIL_COMPONENTS]
+}) => {
+  let logs = [];
+  const logEventEmitter = new EventEmitter2();
+  const addLogEntry = (entry) => {
+    const index = (logs[logs.length - 1]?.index ?? -1) + 1;
+    const trimEntries = Math.max(0, logs.length - MAX_LOG_ENTRIES + 1);
+    logs = [...logs.slice(trimEntries), { index, ...entry }];
+    logEventEmitter.emit("logsUpdated", { logs });
+  };
+  const logError = (level, rootMsg) => {
+    upstreamLogger[level](rootMsg);
+    let error = rootMsg instanceof Error ? rootMsg : null;
+    let message = typeof rootMsg === "string" ? rootMsg : rootMsg.message;
+    while (error) {
+      if (error !== rootMsg) {
+        message += `: ${error.message}`;
+      }
+      error = error.cause instanceof Error ? error.cause : null;
+    }
+    addLogEntry({
+      level,
+      message,
+      timestamp: Date.now(),
+      stack: getStackFramesFromError(rootMsg)
+    });
+  };
+  const logMessage = (level, message) => {
+    upstreamLogger[level](message);
+    addLogEntry({
+      level,
+      message,
+      timestamp: Date.now()
+    });
+  };
+  const logger = {
+    debug: (message) => logMessage("debug", message),
+    info: (message) => logMessage("info", message),
+    warn: (message) => logError("warn", message),
+    error: (message) => logError("error", message)
+  };
+  const toolkit = new Toolkit({
+    log: {
+      ...logger,
+      debug: upstreamLogger.debug.bind(upstreamLogger)
+    },
+    title,
+    ...toolkitOptions
+  });
+  toolkit.start({
+    mode: "manual",
+    setup: () => {
+      logger.info(`${title} ready to start listening`);
+    }
+  });
+  let api = null;
+  const apiListeners = /* @__PURE__ */ new Set();
+  const setAppApi = (value) => {
+    api = value;
+    for (const listener of apiListeners) {
+      listener(value);
+    }
+  };
+  let windowUrl = null;
+  const windowUrlListeners = /* @__PURE__ */ new Set();
+  const setWindowUrl = (value) => {
+    windowUrl = value;
+    for (const listener of windowUrlListeners) {
+      listener(value);
+    }
+  };
+  const shutdownListeners = /* @__PURE__ */ new Set();
+  const shutdownContext = {
+    addShutdownListener: (listener) => {
+      shutdownListeners.add(listener);
+    },
+    removeShutdownListener: (listener) => {
+      shutdownListeners.delete(listener);
+    }
+  };
+  const shutdown = async () => {
+    logger.info(`Shutting down ${title}...`);
+    await Promise.all(
+      Array.from(shutdownListeners).map((listener) => listener())
+    );
+    logger.info(`${title} shutdown complete`);
+  };
+  ToolkitRenderer.render(
+    createApp({
+      title,
+      version,
+      toolkit,
+      logger,
+      logEventEmitter,
+      setAppApi,
+      setWindowUrl,
+      shutdownContext,
+      ...appProps
+    }),
+    toolkit,
+    {},
+    {
+      componentNamespaces
+    }
+  );
+  return {
+    addEventListener: (event, listener) => {
+      if (event === "apiChange") {
+        const apiListener = listener;
+        apiListeners.add(apiListener);
+        if (api) {
+          apiListener(api);
+        }
+        return;
+      }
+      const windowUrlListener = listener;
+      windowUrlListeners.add(windowUrlListener);
+      if (windowUrl) {
+        windowUrlListener(windowUrl);
+      }
+    },
+    shutdown
+  };
+};
+
+// src/app-shell.tsx
+import { jsx } from "react/jsx-runtime";
+var AppShell = ({
+  title,
+  version,
+  dataDirectory,
+  logger,
+  logEventEmitter,
+  shutdownContext,
+  children
+}) => {
+  const [logs, setLogs] = useState([]);
+  const lastLogIndex = logs[logs.length - 1]?.index ?? -1;
+  useEffect2(() => {
+    const listener = ({ logs: logs2 }) => setImmediate(() => setLogs(logs2));
+    logEventEmitter.addListener("logsUpdated", listener);
+    return () => {
+      logEventEmitter.removeListener("logsUpdated", listener);
+    };
+  }, [logEventEmitter]);
+  const system = useMemo(
+    () => createSystemInformation({ dataDirectory, version }),
+    [dataDirectory, version]
+  );
+  const appInformation = useMemo(
+    () => ({ version, title }),
+    [version, title]
+  );
+  return /* @__PURE__ */ jsx(ShutdownContext.Provider, { value: shutdownContext, children: /* @__PURE__ */ jsx(AppInformationContext.Provider, { value: appInformation, children: /* @__PURE__ */ jsx(LoggerContext.Provider, { value: { logger }, children: /* @__PURE__ */ jsx(
+    SIGIL_COMPONENTS.AppRoot,
+    {
+      lastLog: lastLogIndex,
+      system,
+      onGetLogs: async ({ after }) => {
+        return {
+          logs: logs.filter((log) => log.index > after)
+        };
+      },
+      children
+    }
+  ) }) }) });
+};
+
+// src/listener.tsx
+import {
+  getNetworkInterfaces
+} from "@arcanewizards/net-utils";
+import isEqual from "lodash/isEqual";
+import { useCallback, useEffect as useEffect3, useRef, useState as useState2 } from "react";
+var connectionDescription = (listener) => {
+  return `${listener.host ?? "0.0.0.0"}:${listener.port}`;
+};
+var AppListenerManager = ({
+  appRegistration,
+  listenerConfig,
+  toolkit,
+  setWindowUrl
+}) => {
+  const logger = useLogger();
+  const listenerStateRef = useRef({});
+  const [listenerState, setListenerState] = useState2(listenerStateRef.current);
+  const updateReactState = useCallback(() => {
+    setListenerState({ ...listenerStateRef.current });
+  }, []);
+  useEffect3(() => {
+    Object.entries(listenerStateRef.current).forEach(([key, state]) => {
+      if (!listenerConfig[key] || !isEqual(listenerConfig[key], state.config)) {
+        if (state.state === "connected") {
+          const delay = 500;
+          setTimeout(() => {
+            state.listener.close();
+            logger.info(`Closing listener: ${key}`);
+          }, delay);
+          logger.info(
+            `Will close listener ${key} on ${connectionDescription(state)} in ${delay}ms`
+          );
+          appRegistration?.removeConnection(key);
+        }
+        delete listenerStateRef.current[key];
+      }
+    });
+    getNetworkInterfaces().then(async (interfaces) => {
+      listenerLoop: for (const [key, config] of Object.entries(
+        listenerConfig
+      )) {
+        const basePortInformation = {
+          direction: "input",
+          target: config.interface ? {
+            type: "interface",
+            interface: config.interface
+          } : {
+            type: "host",
+            host: "0.0.0.0"
+          },
+          port: config.port
+        };
+        if (!listenerStateRef.current[key]) {
+          let host = void 0;
+          if (config.interface) {
+            const iface = interfaces[config.interface];
+            if (!iface) {
+              const error = new Error(
+                `Network interface ${config.interface} not found`
+              );
+              appRegistration?.setConnection(key, {
+                ...basePortInformation,
+                status: "error",
+                errors: [error.message]
+              });
+              logger.error(error);
+              listenerStateRef.current[key] = {
+                state: "error",
+                config,
+                error: error.message
+              };
+              continue listenerLoop;
+            }
+            host = iface.address;
+          }
+          listenerStateRef.current[key] = { state: "connecting", config };
+          const from = typeof config.port === "number" ? config.port : config.port.from;
+          const to = typeof config.port === "number" ? config.port : config.port.to;
+          portRange: for (let port = from; port <= to; port++) {
+            const resolvedConnectionDetails = {
+              config,
+              host,
+              port
+            };
+            try {
+              const listener = await toolkit.listen({
+                port,
+                host
+              });
+              if (!listenerStateRef.current[key]) {
+                listener.close();
+              } else {
+                listenerStateRef.current[key] = {
+                  state: "connected",
+                  listener,
+                  ...resolvedConnectionDetails
+                };
+                appRegistration?.setConnection(key, {
+                  ...basePortInformation,
+                  port,
+                  status: "active"
+                });
+                logger.info(
+                  `App listener ${key} started on ${connectionDescription(resolvedConnectionDetails)}`
+                );
+                break portRange;
+              }
+            } catch (err) {
+              if (port === to) {
+                const error = new Error(
+                  `Failed to start listener on ${connectionDescription(
+                    resolvedConnectionDetails
+                  )}${from !== to ? ` (for port range ${from}-${to}) latest error` : ""}`,
+                  { cause: err }
+                );
+                listenerStateRef.current[key] = {
+                  state: "error",
+                  config,
+                  error: `${error}`
+                };
+                appRegistration?.setConnection(key, {
+                  ...basePortInformation,
+                  status: "error",
+                  errors: [error.message]
+                });
+                logger.error(error);
+              }
+            } finally {
+              updateReactState();
+            }
+          }
+        }
+      }
+    }).catch((err) => {
+      const error = new Error("Failed to get network interfaces:", {
+        cause: err
+      });
+      logger.error(error);
+      Object.entries(listenerConfig).forEach(([key, config]) => {
+        if (!listenerStateRef.current[key]) {
+          listenerStateRef.current[key] = {
+            state: "error",
+            config,
+            error: `Failed to get network interfaces: ${error}`
+          };
+        }
+      });
+      updateReactState();
+    });
+    updateReactState();
+  }, [appRegistration, listenerConfig, logger, toolkit, updateReactState]);
+  useEffect3(() => {
+    for (const state of Object.values(listenerState)) {
+      if (state.state === "connected") {
+        setWindowUrl(
+          new URL(`http://${state.host ?? "localhost"}:${state.port}/`)
+        );
+        return;
+      }
+    }
+  });
+  return null;
+};
+export {
+  AppInformationContext,
+  AppListenerManager,
+  AppRoot,
+  AppShell,
+  LoggerContext,
+  SIGIL_COMPONENTS,
+  SIGIL_NAMESPACE,
+  ShutdownContext,
+  createSystemInformation,
+  isSigilComponent,
+  isSigilComponentCall,
+  runSigilApp,
+  useLogger,
+  useShutdownHandler
+};

package/dist/proto-B-WcMUOE.d.cts

@@ -0,0 +1,33 @@
+import { BaseClientComponentCall, BaseComponentProto, AnyComponentProto } from '@arcanejs/protocol';
+import { A as AppRootLogEntry, S as SystemInformation } from './types-X8O95zmC.cjs';
+
+declare const SIGIL_NAMESPACE = "sigil";
+type SigilNamespace = typeof SIGIL_NAMESPACE;
+type SigilAppRootComponent = BaseComponentProto<SigilNamespace, 'app-root'> & {
+    child: AnyComponentProto | null;
+    /**
+     * Timestamp of last log entry.
+     * Used to trigger log polling when the frontend debugger is active.
+     */
+    lastLog: number;
+    system: SystemInformation;
+};
+type SigilComponent = SigilAppRootComponent;
+declare const isSigilComponent: (component: AnyComponentProto) => component is SigilComponent;
+type AppRootGetLogsArgs = {
+    after: number;
+};
+type AppRootGetLogsReturn = {
+    logs: AppRootLogEntry[];
+};
+type AppRootGetLogs = BaseClientComponentCall<SigilNamespace, 'app-root-get-logs'> & AppRootGetLogsArgs;
+type SigilComponentCalls = {
+    'app-root-get-logs': {
+        call: AppRootGetLogs;
+        return: AppRootGetLogsReturn;
+    };
+};
+type SigilComponentMessage = never;
+declare const isSigilComponentCall: <A extends keyof SigilComponentCalls>(call: BaseClientComponentCall<string, string>, action: A) => call is SigilComponentCalls[A]["call"];
+
+export { type AppRootGetLogs as A, type SigilAppRootComponent as S, type AppRootGetLogsArgs as a, type AppRootGetLogsReturn as b, SIGIL_NAMESPACE as c, type SigilComponent as d, type SigilComponentCalls as e, isSigilComponentCall as f, type SigilNamespace as g, type SigilComponentMessage as h, isSigilComponent as i };

package/dist/proto-kGDF-yWB.d.ts

@@ -0,0 +1,33 @@
+import { BaseClientComponentCall, BaseComponentProto, AnyComponentProto } from '@arcanejs/protocol';
+import { A as AppRootLogEntry, S as SystemInformation } from './types-X8O95zmC.js';
+
+declare const SIGIL_NAMESPACE = "sigil";
+type SigilNamespace = typeof SIGIL_NAMESPACE;
+type SigilAppRootComponent = BaseComponentProto<SigilNamespace, 'app-root'> & {
+    child: AnyComponentProto | null;
+    /**
+     * Timestamp of last log entry.
+     * Used to trigger log polling when the frontend debugger is active.
+     */
+    lastLog: number;
+    system: SystemInformation;
+};
+type SigilComponent = SigilAppRootComponent;
+declare const isSigilComponent: (component: AnyComponentProto) => component is SigilComponent;
+type AppRootGetLogsArgs = {
+    after: number;
+};
+type AppRootGetLogsReturn = {
+    logs: AppRootLogEntry[];
+};
+type AppRootGetLogs = BaseClientComponentCall<SigilNamespace, 'app-root-get-logs'> & AppRootGetLogsArgs;
+type SigilComponentCalls = {
+    'app-root-get-logs': {
+        call: AppRootGetLogs;
+        return: AppRootGetLogsReturn;
+    };
+};
+type SigilComponentMessage = never;
+declare const isSigilComponentCall: <A extends keyof SigilComponentCalls>(call: BaseClientComponentCall<string, string>, action: A) => call is SigilComponentCalls[A]["call"];
+
+export { type AppRootGetLogs as A, type SigilAppRootComponent as S, type AppRootGetLogsArgs as a, type AppRootGetLogsReturn as b, SIGIL_NAMESPACE as c, type SigilComponent as d, type SigilComponentCalls as e, isSigilComponentCall as f, type SigilNamespace as g, type SigilComponentMessage as h, isSigilComponent as i };