@arcanejs/toolkit 6.0.1 → 7.0.0

package/dist/index.mjs

@@ -1,35 +1,35 @@
 import {
   Tab,
   Tabs
-} from "./chunk-KMEDXCBI.mjs";
+} from "./chunk-R5OA7LLZ.mjs";
 import {
   TextInput
-} from "./chunk-WDB3IMOP.mjs";
+} from "./chunk-GXJ3JRRK.mjs";
 import {
   Timeline
-} from "./chunk-3TXBS2UN.mjs";
+} from "./chunk-6PS3Q66F.mjs";
 import {
   IDMap
 } from "./chunk-RGHJEMWG.mjs";
 import {
   Button
-} from "./chunk-LK6MGXYC.mjs";
+} from "./chunk-7MQHRTBE.mjs";
 import {
   Group,
   GroupHeader
-} from "./chunk-E6FGU7DA.mjs";
+} from "./chunk-TULW7CRV.mjs";
 import {
   Label
-} from "./chunk-UQWCTVMC.mjs";
+} from "./chunk-JHWFQLLE.mjs";
 import {
   Rect
-} from "./chunk-6ELB27LK.mjs";
+} from "./chunk-RJLYYTZ6.mjs";
 import {
   SliderButton
-} from "./chunk-QB2WPBWV.mjs";
+} from "./chunk-K6V55JTG.mjs";
 import {
   Switch
-} from "./chunk-PG5EAV5X.mjs";
+} from "./chunk-MHSAHTVN.mjs";
 import {
   EventEmitter
 } from "./chunk-GONHNB6V.mjs";
@@ -43,7 +43,8 @@ import { diffJson } from "@arcanejs/diff/diff";
 
 // src/backend/options.ts
 var DEFAULT_LIGHT_DESK_OPTIONS = {
-  path: "/"
+  path: "/",
+  clockSync: false
 };
 
 // src/backend/server.ts
@@ -75,93 +76,238 @@ var Server = class {
     this.onClosedConnection = onClosedConnection;
     this.onMessage = onMessage;
     this.log = log;
+    this.title = options.title ?? "@arcanejs";
+  }
+  staticFiles = null;
+  htmlContext = null;
+  staticFilesInitPromise = null;
+  title;
+  getEntrypointPaths = () => {
     const entrypoint = this.options.entrypointJsFile ?? path.join(distDir(), "frontend", "entrypoint.js");
     if (!entrypoint.endsWith(".js")) {
       throw new Error("Entrypoint file must be a .js file");
     }
     const entrypointMap = entrypoint + ".map";
-    this.entrypointFilename = path.basename(entrypoint);
-    this.title = escapeHTML(options.title ?? "@arcanejs");
-    this.staticFiles = {
-      [`/${FONTS.materialSymbolsOutlined}`]: {
-        path: this.options.materialIconsFontFile ?? __require.resolve("material-symbols/material-symbols-outlined.woff2"),
-        contentType: "font/woff2"
-      },
-      [`/${this.entrypointFilename}`]: {
-        path: entrypoint,
-        contentType: "text/javascript"
-      },
-      [`/${path.basename(entrypointMap)}`]: {
-        path: entrypointMap,
-        contentType: "text/plain"
-      }
+    const entrypointCss = entrypoint.replace(/\.js$/, ".css");
+    const entrypointCssMap = entrypointCss + ".map";
+    return {
+      entrypoint,
+      entrypointMap,
+      entrypointCss,
+      entrypointCssMap,
+      entrypointFilename: path.basename(entrypoint),
+      entrypointMapFilename: path.basename(entrypointMap),
+      entrypointCssFilename: path.basename(entrypointCss),
+      entrypointCssMapFilename: path.basename(entrypointCssMap)
     };
-    log?.debug("Static Assets: %o", this.staticFiles);
-  }
-  staticFiles;
-  entrypointFilename;
-  title;
+  };
+  fileExists = async (filePath) => {
+    try {
+      await fs.promises.access(filePath, fs.constants.F_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  ensureStaticFilesInitialized = async () => {
+    if (this.staticFiles && this.htmlContext) return;
+    if (this.staticFilesInitPromise) return this.staticFilesInitPromise;
+    this.staticFilesInitPromise = (async () => {
+      const {
+        entrypoint,
+        entrypointMap,
+        entrypointCss,
+        entrypointCssMap,
+        entrypointFilename,
+        entrypointMapFilename,
+        entrypointCssFilename,
+        entrypointCssMapFilename
+      } = this.getEntrypointPaths();
+      const [hasEntrypointMap, hasEntrypointCss, hasEntrypointCssMap] = await Promise.all([
+        this.fileExists(entrypointMap),
+        this.fileExists(entrypointCss),
+        this.fileExists(entrypointCssMap)
+      ]);
+      const staticFilePaths = {
+        materialSymbolsOutlined: FONTS.materialSymbolsOutlined,
+        entrypointJs: entrypointFilename,
+        ...hasEntrypointMap ? { entrypointJsMap: entrypointMapFilename } : {},
+        ...hasEntrypointCss ? { entrypointCss: entrypointCssFilename } : {},
+        ...hasEntrypointCssMap ? { entrypointCssMap: entrypointCssMapFilename } : {}
+      };
+      const additionalFiles = this.options.additionalFiles ?? {};
+      const additionalFileEntries = Object.entries(additionalFiles).map(
+        ([relativePath, loader]) => [
+          this.toRoutePath(relativePath),
+          async () => {
+            const asset = await loader();
+            if (!Buffer.isBuffer(asset.content)) {
+              throw new Error(
+                `Additional file "${relativePath}" did not return a Buffer in content`
+              );
+            }
+            return asset;
+          }
+        ]
+      );
+      this.staticFiles = {
+        [this.toRoutePath(staticFilePaths.materialSymbolsOutlined)]: async () => ({
+          content: await fs.promises.readFile(
+            this.options.materialIconsFontFile ?? __require.resolve(
+              "material-symbols/material-symbols-outlined.woff2"
+            )
+          ),
+          contentType: "font/woff2"
+        }),
+        [this.toRoutePath(staticFilePaths.entrypointJs)]: async () => ({
+          content: await fs.promises.readFile(entrypoint),
+          contentType: "text/javascript"
+        }),
+        ...hasEntrypointMap ? {
+          [this.toRoutePath(entrypointMapFilename)]: async () => ({
+            content: await fs.promises.readFile(entrypointMap),
+            contentType: "text/plain"
+          })
+        } : {},
+        ...hasEntrypointCss ? {
+          [this.toRoutePath(entrypointCssFilename)]: async () => ({
+            content: await fs.promises.readFile(entrypointCss),
+            contentType: "text/css"
+          })
+        } : {},
+        ...hasEntrypointCssMap ? {
+          [this.toRoutePath(entrypointCssMapFilename)]: async () => ({
+            content: await fs.promises.readFile(entrypointCssMap),
+            contentType: "text/plain"
+          })
+        } : {},
+        ...Object.fromEntries(additionalFileEntries)
+      };
+      this.htmlContext = {
+        title: this.title,
+        path: this.options.path,
+        coreAssets: {
+          materialSymbolsOutlined: this.toSiteRelativeUrl(
+            staticFilePaths.materialSymbolsOutlined
+          ),
+          entrypointJs: this.toSiteRelativeUrl(staticFilePaths.entrypointJs),
+          entrypointJsMap: hasEntrypointMap ? this.toSiteRelativeUrl(entrypointMapFilename) : null,
+          entrypointCss: hasEntrypointCss ? this.toSiteRelativeUrl(entrypointCssFilename) : null,
+          entrypointCssMap: hasEntrypointCssMap ? this.toSiteRelativeUrl(entrypointCssMapFilename) : null
+        },
+        assetUrls: this.createAssetUrls(this.staticFiles)
+      };
+      this.log?.debug("Static Assets: %o", this.staticFiles);
+    })();
+    this.staticFilesInitPromise.catch(() => {
+      this.staticFilesInitPromise = null;
+      this.staticFiles = null;
+      this.htmlContext = null;
+    });
+    return this.staticFilesInitPromise;
+  };
   handleHttpRequest = async (req, res) => {
-    this.log?.debug("handleHttpRequest %s", req.url);
-    if (req.url === this.options.path) {
-      const content = `
+    try {
+      await this.ensureStaticFilesInitialized();
+    } catch (err) {
+      if (err instanceof Error) {
+        this.log?.error(err);
+      } else {
+        this.log?.error("Error preparing static files: %o", err);
+      }
+      res.writeHead(500, { "Content-Type": "text/plain" });
+      res.end("Unable to prepare static files", "utf-8");
+      return;
+    }
+    const htmlContext = this.htmlContext;
+    const staticFiles = this.staticFiles;
+    if (!htmlContext || !staticFiles) {
+      throw new Error("Static assets were not initialized");
+    }
+    const requestUrl = req.originalUrl ?? req.url;
+    this.log?.debug("handleHttpRequest %s", requestUrl);
+    const pathname = this.parsePathname(requestUrl);
+    if (pathname === this.options.path) {
+      const content = await this.options.htmlPage?.(htmlContext) ?? `
           <html>
             <head>
-              <title>${this.title}</title>
+              <title>${escapeHTML(htmlContext.title)}</title>
               <meta charset="utf-8">
               <meta name="viewport" content="width=device-width, initial-scale=1">
               <style type="text/css">
                 @font-face {
                   font-family: 'Material Symbols Outlined';
                   font-style: normal;
-                  src: url(${FONTS.materialSymbolsOutlined}) format('woff');
+                  src: url(${htmlContext.coreAssets.materialSymbolsOutlined}) format('woff');
                 }
               </style>
+              ${htmlContext.coreAssets.entrypointCss ? `<link rel="stylesheet" href="${htmlContext.coreAssets.entrypointCss}" />` : ""}
             </head>
             <body>
               <div id="root"></div>
-              <script type="text/javascript" src="${this.options.path}${this.entrypointFilename}"></script>
+              <script type="text/javascript" src="${htmlContext.coreAssets.entrypointJs}"></script>
             </body>
           </html>`;
       res.writeHead(200, { "Content-Type": "text/html" });
       res.end(content, "utf-8");
       return;
     }
-    if (req.url && req.url.startsWith(this.options.path)) {
-      const relativePath = req.url.substr(this.options.path.length - 1);
-      const f = this.staticFiles[relativePath];
+    if (pathname && pathname.startsWith(this.options.path)) {
+      const relativePath = pathname.substr(this.options.path.length - 1);
+      const f = staticFiles[relativePath];
       if (f) {
-        return fs.promises.stat(f.path).then(
-          () => {
-            this.sendStaticFile(f.path, res, f.contentType);
-          },
-          (err) => {
+        try {
+          const response = await f();
+          res.writeHead(200, { "Content-Type": response.contentType });
+          res.end(response.content);
+          return;
+        } catch (err) {
+          if (err instanceof Error) {
             this.log?.error(err);
-            res.writeHead(500, { "Content-Type": "text/plain" });
-            res.end("Expected static file not found", "utf-8");
+          } else {
+            this.log?.error("Error loading static file: %o", err);
           }
-        );
+          res.writeHead(500, { "Content-Type": "text/plain" });
+          res.end("Expected static file not found", "utf-8");
+          return;
+        }
       }
     }
     res.writeHead(404, { "Content-Type": "text/plain" });
     res.end("not found", "utf-8");
   };
-  sendStaticFile = (file, response, contentType) => {
-    fs.readFile(file, (error, content) => {
-      if (error) {
-        if (error.code === "ENOENT") {
-          response.writeHead(404, { "Content-Type": "text/plain" });
-          response.end("file not found", "utf-8");
-        } else {
-          response.writeHead(500, { "Content-Type": "text/plain" });
-          response.end("Error", "utf-8");
-          this.log?.error(`Error reading static file: %s`, error);
-        }
-      } else {
-        response.writeHead(200, { "Content-Type": contentType });
-        response.end(content, "utf-8");
-      }
-    });
+  parsePathname = (url) => {
+    if (!url) return "";
+    try {
+      return new URL(url, "http://127.0.0.1").pathname;
+    } catch {
+      return url;
+    }
+  };
+  toRoutePath = (relativePath) => {
+    if (!relativePath) {
+      throw new Error("Static file path must be non-empty");
+    }
+    if (relativePath.startsWith("/")) {
+      throw new Error(
+        `Static file path "${relativePath}" must be relative and not start with "/"`
+      );
+    }
+    return `/${relativePath}`;
+  };
+  toSiteRelativeUrl = (relativePath) => {
+    const normalizedPath = relativePath.replace(/^\/+/, "");
+    return `${this.options.path}${normalizedPath}`;
+  };
+  createAssetUrls = (staticFiles) => {
+    const urls = {};
+    for (const routePath of Object.keys(staticFiles)) {
+      const relativePath = routePath.replace(/^\/+/, "");
+      urls[relativePath] = this.toSiteRelativeUrl(
+        relativePath
+      );
+    }
+    return urls;
   };
   handleWsConnection = (ws) => {
     const connection = {
@@ -181,8 +327,23 @@ var Server = class {
 import { WebSocketServer } from "ws";
 import { createServer } from "http";
 import { v4 as uuidv4 } from "uuid";
+var normalizeClockSyncOptions = (clockSync) => {
+  if (!clockSync) {
+    return null;
+  }
+  const { pingIntervalMs } = clockSync;
+  if (!Number.isFinite(pingIntervalMs) || pingIntervalMs <= 0) {
+    throw new Error(
+      `clockSync.pingIntervalMs must be a positive number, got: ${pingIntervalMs}`
+    );
+  }
+  return {
+    pingIntervalMs
+  };
+};
 var Toolkit = class {
   options;
+  clockSync;
   /**
    * Mapping from components to unique IDs that identify them
    */
@@ -197,6 +358,7 @@ var Toolkit = class {
       ...DEFAULT_LIGHT_DESK_OPTIONS,
       ...options
     };
+    this.clockSync = normalizeClockSyncOptions(this.options.clockSync);
     if (!this.options.path.endsWith("/") || !this.options.path.startsWith("/")) {
       throw new Error(
         `path must start and end with "/", set to: ${this.options.path}`
@@ -283,11 +445,15 @@ var Toolkit = class {
     () => {
       setImmediate(() => {
         if (!this.rootGroup) return;
-        const root = this.rootGroup.getProtoInfo(this.componentIDMap);
         for (const [connection, meta] of this.connections.entries()) {
+          const root = this.rootGroup.getProtoInfo(this.componentIDMap, {
+            connection: meta.publicConnection
+          });
+          const diff = diffJson(meta.lastTreeSent, root);
+          if (diff.type === "match") continue;
           connection.sendMessage({
             type: "tree-diff",
-            diff: diffJson(meta.lastTreeSent, root)
+            diff
           });
           meta.lastTreeSent = root;
         }
@@ -303,18 +469,26 @@ var Toolkit = class {
     }
   };
   onNewConnection = (connection) => {
-    const lastTreeSent = this.rootGroup?.getProtoInfo(this.componentIDMap) ?? void 0;
     const uuid = uuidv4();
     const publicConnection = {
       get uuid() {
         return uuid;
       }
     };
-    this.connections.set(connection, { publicConnection, lastTreeSent });
+    const lastTreeSent = this.rootGroup?.getProtoInfo(this.componentIDMap, {
+      connection: publicConnection
+    }) ?? void 0;
+    this.connections.set(connection, {
+      publicConnection,
+      lastTreeSent
+    });
     this.events.emit("new-connection", publicConnection);
     connection.sendMessage({
       type: "metadata",
-      connectionUuid: uuid
+      connectionUuid: uuid,
+      clockSync: this.clockSync ? {
+        pingIntervalMs: this.clockSync.pingIntervalMs
+      } : null
     });
     if (lastTreeSent) {
       connection.sendMessage({
@@ -385,6 +559,14 @@ var Toolkit = class {
       case "component-call":
         this.handleCall(connection, publicConnection, message);
         break;
+      case "ping": {
+        connection.sendMessage({
+          type: "pong",
+          pingId: message.pingId,
+          serverTimeMillis: Date.now()
+        });
+        break;
+      }
     }
   };
 };

package/dist/{toolkit-CohVRj6u.d.mts → toolkit-BPqxbDbk.d.mts}

@@ -12,22 +12,58 @@ import { I as IDMap } from './id-map-DxQ3_gyA.mjs';
 interface Connection {
     sendMessage(msg: ServerMessage): void;
 }
-declare class Server {
+declare class Server<TAdditionalFiles extends ToolkitAdditionalFiles = Record<never, never>> {
     private readonly options;
     private readonly onNewConnection;
     private readonly onClosedConnection;
     private readonly onMessage;
     private readonly log?;
-    private readonly staticFiles;
-    private readonly entrypointFilename;
-    private title;
-    constructor(options: ToolkitOptions, onNewConnection: (connection: Connection) => void, onClosedConnection: (connection: Connection) => void, onMessage: (connection: Connection, message: ClientMessage) => void, log?: Logger | undefined);
+    private staticFiles;
+    private htmlContext;
+    private staticFilesInitPromise;
+    private readonly title;
+    constructor(options: ToolkitOptions<TAdditionalFiles>, onNewConnection: (connection: Connection) => void, onClosedConnection: (connection: Connection) => void, onMessage: (connection: Connection, message: ClientMessage) => void, log?: Logger | undefined);
+    private getEntrypointPaths;
+    private fileExists;
+    private ensureStaticFilesInitialized;
     handleHttpRequest: (req: http.IncomingMessage, res: http.ServerResponse) => Promise<void>;
-    private sendStaticFile;
+    private parsePathname;
+    private toRoutePath;
+    private toSiteRelativeUrl;
+    private createAssetUrls;
     handleWsConnection: <S extends WebSocket>(ws: S) => void;
 }
 
-interface ToolkitOptions {
+declare const FONTS: {
+    readonly materialSymbolsOutlined: "material-symbols-outlined.woff2";
+};
+
+type ToolkitStaticFile = {
+    contentType: string;
+    content: Buffer;
+};
+type ToolkitStaticFileResolver = () => Promise<ToolkitStaticFile>;
+type ToolkitAdditionalFiles = Record<string, ToolkitStaticFileResolver>;
+type ToolkitCoreAssetRelativePath = typeof FONTS.materialSymbolsOutlined | `${string}.js` | `${string}.js.map` | `${string}.css` | `${string}.css.map`;
+type ToolkitHtmlPageContext<TAdditionalFiles extends ToolkitAdditionalFiles> = {
+    title: string;
+    path: string;
+    coreAssets: {
+        materialSymbolsOutlined: string;
+        entrypointJs: string;
+        entrypointJsMap: string | null;
+        entrypointCss: string | null;
+        entrypointCssMap: string | null;
+    };
+    assetUrls: Record<ToolkitCoreAssetRelativePath | Extract<keyof TAdditionalFiles, string>, string>;
+};
+type ToolkitClockSyncOptions = {
+    /**
+     * How often the browser should request a ping in milliseconds.
+     */
+    pingIntervalMs: number;
+};
+interface ToolkitOptions<TAdditionalFiles extends ToolkitAdditionalFiles = Record<never, never>> {
     /**
      * What window title should the toolkit be initialized with?
      */
@@ -53,8 +89,10 @@ interface ToolkitOptions {
      * This is only needed if you have defined custom extensions,
      * and need to load custom frontend code that includes your extensions.
      *
-     * This will allow access to both the js file and the `.map.js` file,
-     * that matches this name.
+     * ArcaneJS expects an associated `.css` file with the same basename
+     * (for example `entrypoint.js` + `entrypoint.css`) so browser styles are
+     * served automatically. Source map files (`.js.map`, `.css.map`) are optional,
+     * and exposed when present.
      */
     entrypointJsFile?: string;
     /**
@@ -64,8 +102,29 @@ interface ToolkitOptions {
      * you can provide the path to the material-symbols-outlined.woff2 file here.
      */
     materialIconsFontFile?: string;
+    /**
+     * Additional static assets that should be exposed from the toolkit path.
+     *
+     * The object key is the relative request path (for example `styles/app.css`),
+     * and the loader returns the response payload and content type.
+     */
+    additionalFiles?: TAdditionalFiles;
+    /**
+     * Optional custom HTML renderer for the root page.
+     *
+     * Receives resolved site-relative URLs for all available static assets,
+     * including toolkit defaults and files provided by `additionalFiles`.
+     */
+    htmlPage?: (context: ToolkitHtmlPageContext<TAdditionalFiles>) => string | Promise<string>;
+    /**
+     * Enable browser/server clock synchronization support.
+     *
+     * When enabled, frontend clients will periodically ping the toolkit server
+     * and expose a calculated server clock offset in stage context.
+     */
+    clockSync?: false | ToolkitClockSyncOptions;
 }
-type InitializationOptions = 
+type InitializationOptions<TAdditionalFiles extends ToolkitAdditionalFiles = Record<never, never>> = 
 /** automatically start a simple  */
 {
     mode: 'automatic';
@@ -85,7 +144,7 @@ type InitializationOptions =
 /** Create a websocket server that attaches to an existing express and http server */
  | {
     mode: 'manual';
-    setup: (server: Server) => void;
+    setup: (server: Server<TAdditionalFiles>) => void;
 };
 
 declare abstract class Base<Namespace extends string, Proto extends BaseComponentProto<Namespace, string>, Props, CallPairs = any, CallActions extends string & keyof CallPairs = any> {
@@ -114,7 +173,7 @@ declare abstract class Base<Namespace extends string, Proto extends BaseComponen
     /** @hidden */
     updateTree(): void;
     /** @hidden */
-    abstract getProtoInfo(idMap: IDMap): Proto;
+    abstract getProtoInfo(idMap: IDMap, context: ToolkitRenderContext): Proto;
     /** @hidden */
     handleMessage(_message: AnyClientComponentMessage, _connection: ToolkitConnection): void;
     /** @hidden */
@@ -199,7 +258,7 @@ declare class Button extends Base<proto.CoreNamespace, proto.ButtonComponent, In
     setIcon: (icon: string | undefined | null) => this;
     setMode: (mode: ButtonMode) => this;
     /** @hidden */
-    getProtoInfo: (idMap: IDMap) => proto.ButtonComponent;
+    getProtoInfo: (idMap: IDMap, _context: ToolkitRenderContext) => proto.ButtonComponent;
     /** @hidden */
     handleCall: (call: AnyClientComponentCall, connection: ToolkitConnection) => Promise<true>;
 }
@@ -221,7 +280,7 @@ type Props = Partial<InternalProps>;
 declare class GroupHeader extends BaseParent<proto.CoreNamespace, proto.CoreComponent, Record<never, never>> {
     validateChildren: () => void;
     /** @hidden */
-    getProtoInfo: (idMap: IDMap) => proto.GroupHeaderComponent;
+    getProtoInfo: (idMap: IDMap, context: ToolkitRenderContext) => proto.GroupHeaderComponent;
 }
 /**
  * A collection of components, grouped in either a row or column. Can contain
@@ -245,7 +304,7 @@ declare class Group extends BaseParent<proto.CoreNamespace, proto.GroupComponent
     removeHeaderChild: (child: Button) => void;
     removeAllHeaderChildren: () => void;
     /** @hidden */
-    getProtoInfo: (idMap: IDMap) => proto.GroupComponent;
+    getProtoInfo: (idMap: IDMap, context: ToolkitRenderContext) => proto.GroupComponent;
     /** @hidden */
     handleMessage: (message: AnyClientComponentMessage, connection: ToolkitConnection) => void;
 }
@@ -253,6 +312,9 @@ declare class Group extends BaseParent<proto.CoreNamespace, proto.GroupComponent
 type ToolkitConnection = {
     uuid: string;
 };
+type ToolkitRenderContext = {
+    connection: ToolkitConnection;
+};
 type Events = {
     'new-connection': (connection: ToolkitConnection) => void;
     'closed-connection': (connection: ToolkitConnection) => void;
@@ -264,8 +326,9 @@ type ToolkitServerListenerOptions = {
 type ToolkitServerListener = {
     close: () => void;
 };
-declare class Toolkit implements Parent, Listenable<Events> {
+declare class Toolkit<TAdditionalFiles extends ToolkitAdditionalFiles = Record<never, never>> implements Parent, Listenable<Events> {
     private readonly options;
+    private readonly clockSync;
     /**
      * Mapping from components to unique IDs that identify them
      */
@@ -275,10 +338,10 @@ declare class Toolkit implements Parent, Listenable<Events> {
     /** @hidden */
     private readonly events;
     private readonly server;
-    constructor(options?: Partial<ToolkitOptions>);
+    constructor(options?: Partial<ToolkitOptions<TAdditionalFiles>>);
     addListener: <T extends keyof Events>(type: T, listener: Events[T]) => void;
     removeListener: <T extends keyof Events>(type: T, listener: Events[T]) => void;
-    start: (opts: InitializationOptions) => void;
+    start: (opts: InitializationOptions<TAdditionalFiles>) => void;
     listen: ({ port, host, }: ToolkitServerListenerOptions) => Promise<ToolkitServerListener>;
     setRoot: (group: Group) => void;
     log(): _arcanejs_protocol_logging.Logger | null;
@@ -291,4 +354,4 @@ declare class Toolkit implements Parent, Listenable<Events> {
     private onMessage;
 }
 
-export { type AnyComponent as A, Button as B, EventEmitter as E, Group as G, type InternalProps$1 as I, type Listenable as L, type Parent as P, Toolkit as T, type ToolkitConnection as a, type ToolkitServerListenerOptions as b, type ToolkitServerListener as c, type ToolkitOptions as d, GroupHeader as e, Base as f, BaseParent as g, type Events$2 as h, type ButtonMode as i, type Props$1 as j, type Events$1 as k, type InternalProps as l, type Props as m };
+export { type AnyComponent as A, Button as B, EventEmitter as E, Group as G, type InternalProps$1 as I, type Listenable as L, type Parent as P, Toolkit as T, type ToolkitConnection as a, type ToolkitRenderContext as b, type ToolkitServerListenerOptions as c, type ToolkitServerListener as d, type ToolkitAdditionalFiles as e, type ToolkitClockSyncOptions as f, type ToolkitCoreAssetRelativePath as g, type ToolkitHtmlPageContext as h, type ToolkitOptions as i, type ToolkitStaticFile as j, type ToolkitStaticFileResolver as k, GroupHeader as l, Base as m, BaseParent as n, type Events$2 as o, type ButtonMode as p, type Props$1 as q, type Events$1 as r, type InternalProps as s, type Props as t };