@nice-code/action 0.2.11 → 0.2.13

package/build/devtools/server/index.js

@@ -0,0 +1,235 @@
+// src/ActionDefinition/Action/RunningAction.types.ts
+var ERunningActionState;
+((ERunningActionState2) => {
+  ERunningActionState2["running"] = "running";
+  ERunningActionState2["completed"] = "completed";
+})(ERunningActionState ||= {});
+var ERunningActionUpdateType;
+((ERunningActionUpdateType2) => {
+  ERunningActionUpdateType2["started"] = "started";
+  ERunningActionUpdateType2["progress"] = "progress";
+  ERunningActionUpdateType2["finished"] = "finished";
+})(ERunningActionUpdateType ||= {});
+var ERunningActionFinishedType;
+((ERunningActionFinishedType2) => {
+  ERunningActionFinishedType2["aborted"] = "aborted";
+  ERunningActionFinishedType2["failed"] = "failed";
+  ERunningActionFinishedType2["success"] = "success";
+})(ERunningActionFinishedType ||= {});
+
+// src/devtools/server/NiceActionServerDevtools.ts
+class ActionServerDevtools {
+  _options;
+  _inFlight = new Map;
+  constructor(options = {}) {
+    const defaultEnabled = typeof process !== "undefined" ? true : true;
+    this._options = {
+      logger: options.logger ?? defaultConsoleLogger,
+      format: options.format ?? "pretty",
+      logPayloads: options.logPayloads ?? true,
+      enabled: options.enabled ?? defaultEnabled
+    };
+  }
+  attachToDomain(domain) {
+    if (!this._options.enabled) {
+      return () => {};
+    }
+    return domain.addActionListener((update) => {
+      const { runningAction, type, time } = update;
+      const actionPath = [...runningAction.allDomains, runningAction.id].join(".");
+      if (type === "started" /* started */) {
+        this._inFlight.set(runningAction.cuid, { startTime: time });
+        this._log("started", actionPath, runningAction.cuid, {
+          ...this._options.logPayloads ? { input: runningAction.state?.request?.input } : {}
+        });
+      } else if (type === "progress" /* progress */) {
+        this._log("progress", actionPath, runningAction.cuid, { progress: update.progress });
+      } else if (type === "finished" /* finished */) {
+        const timing = this._inFlight.get(runningAction.cuid);
+        const duration = timing != null ? time - timing.startTime : undefined;
+        this._inFlight.delete(runningAction.cuid);
+        const finishType = update.finishType;
+        if (finishType === "success" /* success */) {
+          this._log("success", actionPath, runningAction.cuid, {
+            ...duration != null ? { duration: `${duration}ms` } : {},
+            ...this._options.logPayloads ? { output: update.response?.result?.output } : {}
+          });
+        } else if (finishType === "failed" /* failed */) {
+          this._log("failed", actionPath, runningAction.cuid, {
+            ...duration != null ? { duration: `${duration}ms` } : {},
+            error: serializeError(update.error)
+          });
+        } else {
+          this._log("aborted", actionPath, runningAction.cuid, {
+            ...duration != null ? { duration: `${duration}ms` } : {},
+            ...update.reason != null ? { reason: String(update.reason) } : {}
+          });
+        }
+      }
+    });
+  }
+  _log(event, actionPath, cuid, data) {
+    const { logger, format } = this._options;
+    if (format === "json") {
+      logger(JSON.stringify({ time: new Date().toISOString(), event, action: actionPath, cuid, ...data }));
+      return;
+    }
+    const prefix = PRETTY_PREFIX[event] ?? `[${event}]`;
+    const suffix = Object.keys(data).length > 0 ? `  ${formatPrettyData(data)}` : "";
+    logger(`${prefix} ${actionPath}  cuid=${cuid}${suffix}`);
+  }
+}
+var PRETTY_PREFIX = {
+  started: "[nice-action] ►",
+  progress: "[nice-action]  ",
+  success: "[nice-action] ✓",
+  failed: "[nice-action] ✗",
+  aborted: "[nice-action] ○"
+};
+function formatPrettyData(data) {
+  return Object.entries(data).map(([k, v]) => `${k}=${safeStringify(v)}`).join(" ");
+}
+function safeStringify(value) {
+  if (value === undefined)
+    return "undefined";
+  if (value === null)
+    return "null";
+  if (typeof value === "string")
+    return `"${value}"`;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function serializeError(err) {
+  if (err == null)
+    return err;
+  if (err instanceof Error)
+    return { message: err.message, name: err.name, stack: err.stack };
+  if (typeof err === "object") {
+    try {
+      return JSON.parse(JSON.stringify(err));
+    } catch {
+      return String(err);
+    }
+  }
+  return err;
+}
+function defaultConsoleLogger(message) {
+  console.log(message);
+}
+// src/devtools/core/ActionDevtoolsCore.ts
+function extractRouting(context) {
+  return (context?.routing ?? []).map((item) => {
+    const handler = item.handler;
+    const isExternal = handler?.type === "external";
+    return {
+      runtime: {
+        envId: item.runtime?.envId ?? "unknown",
+        perId: item.runtime?.perId,
+        insId: item.runtime?.insId
+      },
+      handlerType: isExternal ? "external" : "local",
+      handlerClient: isExternal && handler.client != null ? {
+        envId: handler.client.envId ?? "unknown",
+        perId: handler.client.perId,
+        insId: handler.client.insId
+      } : undefined,
+      transport: isExternal ? handler.transType : undefined,
+      time: item.time
+    };
+  });
+}
+function extractMeta(context) {
+  return {
+    timeCreated: context?.timeCreated ?? Date.now(),
+    originClient: {
+      envId: context?.originClient?.envId ?? "unknown",
+      perId: context?.originClient?.perId,
+      insId: context?.originClient?.insId
+    },
+    routing: extractRouting(context)
+  };
+}
+
+class ActionDevtoolsCore {
+  _entries = [];
+  _listeners = new Set;
+  constructor(_options = {}) {}
+  attachToDomain(domain) {
+    return domain.addActionListener((update) => {
+      const { runningAction, type, time } = update;
+      if (type === "started" /* started */) {
+        const entry = {
+          cuid: runningAction.cuid,
+          actionId: runningAction.id,
+          domain: runningAction.domain,
+          allDomains: [...runningAction.allDomains],
+          status: "running",
+          startTime: time,
+          input: runningAction.state?.request?.input,
+          progressUpdates: [],
+          meta: extractMeta(runningAction.context),
+          parentCuid: runningAction.parentCuid,
+          callSite: runningAction.callSite
+        };
+        this._entries = [entry, ...this._entries];
+        this._notify();
+      } else if (type === "progress" /* progress */) {
+        this._updateEntry(runningAction.cuid, (e) => ({
+          ...e,
+          progressUpdates: [...e.progressUpdates, update.progress]
+        }));
+      } else if (type === "finished" /* finished */) {
+        this._updateEntry(runningAction.cuid, (e) => {
+          const finishedRoutingContext = update.response?.context ?? runningAction.context;
+          const base = {
+            ...e,
+            endTime: time,
+            meta: { ...e.meta, routing: extractRouting(finishedRoutingContext) }
+          };
+          const finishType = update.finishType;
+          if (finishType === "success" /* success */) {
+            return { ...base, status: "success", output: update.response?.result?.output };
+          }
+          if (finishType === "failed" /* failed */) {
+            const rawError = update.error;
+            const errorStack2 = rawError instanceof Error ? rawError.stack : undefined;
+            return { ...base, status: "failed", error: rawError, errorStack: errorStack2 };
+          }
+          const abortReason = update.reason;
+          const errorStack = abortReason instanceof Error ? abortReason.stack : undefined;
+          return { ...base, status: "aborted", abortReason, errorStack };
+        });
+      }
+    });
+  }
+  getEntries() {
+    return this._entries;
+  }
+  subscribe(listener) {
+    this._listeners.add(listener);
+    listener(this._entries);
+    return () => {
+      this._listeners.delete(listener);
+    };
+  }
+  clear() {
+    this._entries = [];
+    this._notify();
+  }
+  _updateEntry(cuid, updater) {
+    this._entries = this._entries.map((e) => e.cuid === cuid ? updater(e) : e);
+    this._notify();
+  }
+  _notify() {
+    const snapshot = this._entries;
+    for (const listener of this._listeners)
+      listener(snapshot);
+  }
+}
+export {
+  ActionServerDevtools,
+  ActionDevtoolsCore
+};

package/build/index.js

@@ -37,19 +37,19 @@ class RuntimeCoordinate {
     this.perId = perId;
     this.insId = insId;
   }
-  specify(newInputs) {
+  specify(specifics) {
     return new RuntimeCoordinate({
       envId: this.envId,
       perId: this.perId,
       insId: this.insId,
-      ...newInputs
+      ...specifics
     });
   }
-  specifyIfUnset(newInputs) {
+  specifyIfUnset(specifics) {
     return new RuntimeCoordinate({
       envId: this.envId,
-      perId: this.perId ?? newInputs.perId,
-      insId: this.insId ?? newInputs.insId
+      perId: this.perId ?? specifics.perId,
+      insId: this.insId ?? specifics.insId
     });
   }
   toJsonObject() {
@@ -271,6 +271,7 @@ class ActionPayload_Result extends ActionPayload {
 // src/ActionDefinition/Action/Payload/ActionPayload_Request.ts
 class ActionPayload_Request extends ActionPayload {
   input;
+  _callSite;
   constructor(params, input, data) {
     super(params.context, "request" /* request */, data);
     this.input = input;
@@ -310,6 +311,7 @@ class ActionPayload_Request extends ActionPayload {
     return value.waitForResultPayload();
   }
   async run(options) {
+    this._callSite = new Error().stack;
     return this._domain.runAction(this, options);
   }
 }
@@ -396,6 +398,8 @@ class RunningAction {
   _domain;
   domain;
   allDomains;
+  parentCuid;
+  callSite;
   _resultPayloadPromise;
   _resolveResult;
   _rejectResult;
@@ -409,6 +413,8 @@ class RunningAction {
     this.domain = initialState.context.domain;
     this.allDomains = initialState.context.allDomains;
     this._domain = initialState.context._domain;
+    this.parentCuid = initialState.parentCuid;
+    this.callSite = initialState.callSite;
     this._resultPayloadPromise = new Promise((resolve, reject) => {
       this._resolveResult = resolve;
       this._rejectResult = reject;
@@ -864,13 +870,13 @@ class ActionRuntime {
   get coordinate() {
     return this._coordinate;
   }
-  updateRuntimeCoordinate(newCoordinate) {
-    if (this._coordinate.envId !== newCoordinate.envId) {
+  specifyRuntimeCoordinate(specifics) {
+    if (specifics.envId != null && this._coordinate.envId !== specifics.envId) {
       throw err_nice_action.fromId("not_implemented" /* not_implemented */, {
-        label: `updating RuntimeCoordinate with a different "envId" ("${this._coordinate.envId}" → "${newCoordinate.envId}")`
+        label: `updating RuntimeCoordinate with a different "envId" ("${this._coordinate.envId}" → "${specifics.envId}")`
       });
     }
-    this._coordinate = newCoordinate;
+    this._coordinate = this._coordinate.specify(specifics);
     this.apply();
   }
   registerRunningAction(ra) {
@@ -1044,6 +1050,18 @@ function getDefaultActionRuntime() {
   return runtimeState.defaultLocalRuntime;
 }
 
+// src/ActionRuntime/HandlerCallStack.ts
+var _stack = [];
+function pushHandlerCuid(cuid) {
+  _stack.push(cuid);
+}
+function popHandlerCuid() {
+  _stack.pop();
+}
+function peekHandlerCuid() {
+  return _stack[_stack.length - 1];
+}
+
 // src/ActionRuntime/Handler/ActionHandler.ts
 import { nanoid as nanoid3 } from "nanoid";
 
@@ -1093,7 +1111,12 @@ class ActionLocalHandler extends ActionHandler {
       handler: this.toHandlerRouteItem(),
       time: Date.now()
     });
-    const runningAction = new RunningAction({ context: action.context, request: action });
+    const runningAction = new RunningAction({
+      context: action.context,
+      request: action,
+      parentCuid: peekHandlerCuid(),
+      callSite: action._callSite ?? new Error().stack
+    });
     this._handleRunningAction(handler, runningAction).catch((err2) => runningAction._abort(err2));
     return runningAction;
   }
@@ -1102,17 +1125,22 @@ class ActionLocalHandler extends ActionHandler {
     if (state.result != null) {
       return;
     }
-    const rawResult = await handler(state.request);
-    let result;
-    if (rawResult instanceof ActionPayload_Result) {
-      result = rawResult;
-    } else if (rawResult != null && isActionPayload_Result_JsonObject(rawResult)) {
-      const domain = this.actionRouter.domainManager.getActionDomainOrThrow(state.request);
-      result = domain.hydrateResultPayload(rawResult);
-    } else {
-      result = state.request.successResult(rawResult);
+    pushHandlerCuid(runningAction.cuid);
+    try {
+      const rawResult = await handler(state.request);
+      let result;
+      if (rawResult instanceof ActionPayload_Result) {
+        result = rawResult;
+      } else if (rawResult != null && isActionPayload_Result_JsonObject(rawResult)) {
+        const domain = this.actionRouter.domainManager.getActionDomainOrThrow(state.request);
+        result = domain.hydrateResultPayload(rawResult);
+      } else {
+        result = state.request.successResult(rawResult);
+      }
+      runningAction._completeWithResult(result);
+    } finally {
+      popHandlerCuid();
     }
-    runningAction._completeWithResult(result);
   }
   async handlePayloadWireOrThrow(wire, config) {
     const hydratedAction = this.actionRouter.domainManager.hydrateActionPayload(wire);
@@ -2179,6 +2207,8 @@ class ActionExternalClientHandler extends ActionHandler {
     const localRuntime = config?.targetLocalRuntime ?? ActionRuntime.getDefault();
     const localClient = localRuntime.coordinate;
     const incomingTimeout = config?.timeout ?? this._defaultTimeout;
+    const parentCuid = peekHandlerCuid();
+    const callSite = action._callSite ?? new Error().stack;
     const { methods, transport } = await this.transportManager.getReadyTransport({
       action,
       localClient,
@@ -2189,7 +2219,7 @@ class ActionExternalClientHandler extends ActionHandler {
       handler: this.toHandlerRouteItem(transport),
       time: Date.now()
     });
-    const runningAction = new RunningAction({ context: action.context, request: action });
+    const runningAction = new RunningAction({ context: action.context, request: action, parentCuid, callSite });
     localRuntime.registerRunningAction(runningAction);
     const routeActionParams = {
       action,

package/build/types/ActionDefinition/Action/Payload/ActionPayload_Request.d.ts

@@ -10,6 +10,7 @@ import { ActionPayload_Progress } from "./ActionPayload_Progress";
 import { ActionPayload_Result } from "./ActionPayload_Result";
 export declare class ActionPayload_Request<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends ActionPayload<EActionPayloadType.request, DOM, ID> {
     readonly input: TInferInputFromSchema<DOM["actionSchema"][ID]>["Input"];
+    _callSite?: string;
     constructor(params: {
         context: ActionContext<DOM, ID>;
     }, input: TInferInputFromSchema<DOM["actionSchema"][ID]>["Input"], data: IActionPayload_Data_Base);

package/build/types/ActionDefinition/Action/RunningAction.d.ts

@@ -13,6 +13,8 @@ export declare class RunningAction<DOM extends IActionDomain, ID extends keyof D
     readonly _domain: ActionDomain<DOM>;
     readonly domain: DOM["domain"];
     readonly allDomains: DOM["allDomains"];
+    readonly parentCuid?: string;
+    readonly callSite?: string;
     private readonly _resultPayloadPromise;
     private _resolveResult;
     private _rejectResult;

package/build/types/ActionDefinition/Action/RunningAction.types.d.ts

@@ -20,6 +20,8 @@ export interface IRunningActionState_ConstructorParams<DOM extends IActionDomain
     request: ActionPayload_Request<DOM, ID>;
     progress?: ActionPayload_Progress<DOM, ID>[];
     result?: ActionPayload_Result<DOM, ID>;
+    parentCuid?: string;
+    callSite?: string;
 }
 export declare enum ERunningActionUpdateType {
     started = "started",

package/build/types/ActionRuntime/ActionRuntime.d.ts

@@ -5,7 +5,7 @@ import type { IActionDomain } from "../ActionDefinition/Domain/ActionDomain.type
 import type { IRuntimeMeta, TActionRuntimeHandler } from "./ActionRuntime.types";
 import { type IHandleActionOptions, type TActionHandler } from "./Handler/ActionHandler.types";
 import type { ActionExternalClientHandler } from "./Handler/ExternalClient/ActionExternalClientHandler";
-import { RuntimeCoordinate } from "./RuntimeCoordinate";
+import { type IRuntimeCoordinateSpecifics, RuntimeCoordinate } from "./RuntimeCoordinate";
 export declare class ActionRuntime {
     private _coordinate;
     readonly timeCreated: number;
@@ -17,7 +17,9 @@ export declare class ActionRuntime {
     static getDefault(): ActionRuntime;
     constructor(coordinate: RuntimeCoordinate);
     get coordinate(): RuntimeCoordinate;
-    updateRuntimeCoordinate(newCoordinate: RuntimeCoordinate): void;
+    specifyRuntimeCoordinate(specifics: IRuntimeCoordinateSpecifics & {
+        envId?: string;
+    }): void;
     registerRunningAction(ra: RunningAction<any, any>): void;
     resolveIncomingActionPayload(json: TActionPayload_Any_JsonObject<any, any>): void;
     /**

package/build/types/ActionRuntime/HandlerCallStack.d.ts

@@ -0,0 +1,3 @@
+export declare function pushHandlerCuid(cuid: string): void;
+export declare function popHandlerCuid(): void;
+export declare function peekHandlerCuid(): string | undefined;

package/build/types/ActionRuntime/RuntimeCoordinate.d.ts

@@ -1,8 +1,4 @@
-export interface IRuntimeCoordinate {
-    /**
-     * A static runtime environment identifier (e.g. "web_app_v1", "backend_analytics")
-     */
-    envId: string;
+export interface IRuntimeCoordinateSpecifics {
     /**
      * A unique and persistent client ID (should stay the same between runtime instance reloads)
      */
@@ -13,6 +9,12 @@ export interface IRuntimeCoordinate {
      */
     insId?: string;
 }
+export interface IRuntimeCoordinate extends IRuntimeCoordinateSpecifics {
+    /**
+     * A static runtime environment identifier (e.g. "web_app_v1", "backend_analytics")
+     */
+    envId: string;
+}
 export type TRuntimeCoordinateEnvId = `envId[${string}]`;
 export type TRuntimeCoordinateStringId = `${TRuntimeCoordinateEnvId}perId[${string | "_"}]:insId[${string | "_"}]`;
 export interface IRuntimeFullCoordinates extends Required<IRuntimeCoordinate> {
@@ -25,8 +27,8 @@ export declare class RuntimeCoordinate implements IRuntimeCoordinate {
     static env(envId: string): RuntimeCoordinate;
     withPersistentId(perId: string): RuntimeCoordinate;
     constructor({ envId, perId, insId }: IRuntimeCoordinate);
-    specify(newInputs: Omit<IRuntimeCoordinate, "envId">): RuntimeCoordinate;
-    specifyIfUnset(newInputs: Omit<IRuntimeCoordinate, "envId">): RuntimeCoordinate;
+    specify(specifics: IRuntimeCoordinateSpecifics): RuntimeCoordinate;
+    specifyIfUnset(specifics: IRuntimeCoordinateSpecifics): RuntimeCoordinate;
     toJsonObject(): IRuntimeCoordinate;
     isExactlySame(other: IRuntimeCoordinate): boolean;
     isSameFor(other: IRuntimeCoordinate): {

package/build/types/devtools/browser/NiceActionDevtools.d.ts

@@ -0,0 +1,8 @@
+import type { TDevtoolsPosition } from "../core/ActionDevtools.types";
+import type { ActionDevtoolsCore } from "../core/ActionDevtoolsCore";
+export interface INiceActionDevtoolsProps {
+    core: ActionDevtoolsCore;
+    position?: TDevtoolsPosition;
+    initialOpen?: boolean;
+}
+export declare function NiceActionDevtools(props: INiceActionDevtoolsProps): import("react/jsx-runtime").JSX.Element | null;

package/build/types/devtools/browser/components/ActionDetailPanel.d.ts

@@ -0,0 +1,7 @@
+import type { IDevtoolsActionEntry } from "../../core/ActionDevtools.types";
+export declare function ActionDetailPanel({ entry, parent, childEntries, onSelectEntry, }: {
+    entry: IDevtoolsActionEntry;
+    parent: IDevtoolsActionEntry | null;
+    childEntries: IDevtoolsActionEntry[];
+    onSelectEntry: (cuid: string) => void;
+}): import("react/jsx-runtime").JSX.Element;

package/build/types/devtools/browser/components/ActionEntryRow.d.ts

@@ -0,0 +1,11 @@
+import type { IDevtoolsActionEntry } from "../../core/ActionDevtools.types";
+export declare function ActionEntryRow({ entry, isSelected, onClick, groupCount, isSubEntry, isLatest, latestTime, childExternalLabels, }: {
+    entry: IDevtoolsActionEntry;
+    isSelected: boolean;
+    onClick: () => void;
+    groupCount?: number;
+    isSubEntry?: boolean;
+    isLatest?: boolean;
+    latestTime?: number;
+    childExternalLabels?: string[];
+}): import("react/jsx-runtime").JSX.Element;

package/build/types/devtools/browser/components/CallStackSection.d.ts

@@ -0,0 +1,8 @@
+import type { IDevtoolsActionEntry } from "../../core/ActionDevtools.types";
+export declare function CallStackSection({ parent, childEntries, focusedChildCuid, onFocusChild, onSelectParent, }: {
+    parent: IDevtoolsActionEntry | null;
+    childEntries: IDevtoolsActionEntry[];
+    focusedChildCuid: string | null;
+    onFocusChild: (cuid: string) => void;
+    onSelectParent: (cuid: string) => void;
+}): import("react/jsx-runtime").JSX.Element | null;

package/build/types/devtools/browser/components/ChildDispatchChips.d.ts

@@ -0,0 +1,4 @@
+export declare function ChildDispatchChips({ labels, size, }: {
+    labels?: string[];
+    size?: "sm" | "md";
+}): import("react/jsx-runtime").JSX.Element | null;

package/build/types/devtools/browser/components/Chip.d.ts

@@ -0,0 +1,11 @@
+import type { CSSProperties, ReactNode } from "react";
+interface IChipProps {
+    color: string;
+    borderColor: string;
+    fontSize?: string;
+    padding?: string;
+    children: ReactNode;
+    style?: CSSProperties;
+}
+export declare function Chip({ color, borderColor, fontSize, padding, children, style, }: IChipProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/build/types/devtools/browser/components/DetailSection.d.ts

@@ -0,0 +1,5 @@
+export declare function DetailSection({ label, value, color, }: {
+    label: string;
+    value: unknown;
+    color?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/build/types/devtools/browser/components/DomainChip.d.ts

@@ -0,0 +1,14 @@
+export interface IDomainTooltipCtx {
+    show: (rect: DOMRect, allDomains: string[]) => void;
+    hide: () => void;
+}
+export declare const DomainTooltipCtx: import("react").Context<IDomainTooltipCtx | null>;
+export declare function DomainHierarchyTooltip({ allDomains, anchor, }: {
+    allDomains: string[];
+    anchor: DOMRect;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function DomainChip({ domain, allDomains, size, }: {
+    domain: string;
+    allDomains?: string[];
+    size: "sm" | "md";
+}): import("react/jsx-runtime").JSX.Element;

package/build/types/devtools/browser/components/HandlerChips.d.ts

@@ -0,0 +1,10 @@
+import type { IDevtoolsActionEntry, IDevtoolsRouteItem } from "../../core/ActionDevtools.types";
+export declare function getExternalLabel(hop: IDevtoolsRouteItem): string | null;
+interface IHandlerChipsProps {
+    entry: IDevtoolsActionEntry;
+    size: "sm" | "md";
+    /** Show the local runtime chip even when an external chip is also present */
+    alwaysShowLocal?: boolean;
+}
+export declare function HandlerChips({ entry, size, alwaysShowLocal }: IHandlerChipsProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/build/types/devtools/browser/components/MetaSection.d.ts

@@ -0,0 +1,4 @@
+import type { IDevtoolsActionEntry } from "../../core/ActionDevtools.types";
+export declare function MetaSection({ entry }: {
+    entry: IDevtoolsActionEntry;
+}): import("react/jsx-runtime").JSX.Element;

package/build/types/devtools/browser/components/PanelChrome.d.ts

@@ -0,0 +1,14 @@
+import type { TDevtoolsPosition } from "../../core/ActionDevtools.types";
+export type TDockSide = "top" | "bottom" | "left" | "right";
+export declare function getDockSide(pos: TDevtoolsPosition): TDockSide | null;
+export declare function PanelHeader({ position, onPositionChange, onClose, onClear, }: {
+    position: TDevtoolsPosition;
+    onPositionChange: (p: TDevtoolsPosition) => void;
+    onClose: () => void;
+    onClear?: () => void;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function ResizeHandle({ dockSide, dockedSize, onChange, }: {
+    dockSide: TDockSide;
+    dockedSize: number;
+    onChange: (size: number) => void;
+}): import("react/jsx-runtime").JSX.Element;

package/build/types/devtools/browser/components/RoutingSection.d.ts

@@ -0,0 +1,5 @@
+import type { IDevtoolsActionEntry } from "../../core/ActionDevtools.types";
+export declare function RoutingSection({ entry, minHopCount, }: {
+    entry: IDevtoolsActionEntry;
+    minHopCount?: number;
+}): import("react/jsx-runtime").JSX.Element | null;

package/build/types/devtools/browser/components/RunningTimer.d.ts

@@ -0,0 +1,7 @@
+import type { IDevtoolsActionEntry } from "../../core/ActionDevtools.types";
+export declare function RunningTimer({ startTime }: {
+    startTime: number;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function DurationDisplay({ entry }: {
+    entry: IDevtoolsActionEntry;
+}): import("react/jsx-runtime").JSX.Element;

package/build/types/devtools/browser/components/SectionLabel.d.ts

@@ -0,0 +1,4 @@
+export declare function SectionLabel({ label, color }: {
+    label: string;
+    color?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/build/types/devtools/browser/components/StackTraceSection.d.ts

@@ -0,0 +1,5 @@
+export declare function StackTraceSection({ label, stack, color, }: {
+    label: string;
+    stack: string | undefined;
+    color?: string;
+}): import("react/jsx-runtime").JSX.Element | null;

package/build/types/devtools/browser/components/utils.d.ts

@@ -0,0 +1,7 @@
+import type { IDevtoolsActionEntry, TDevtoolsActionStatus } from "../../core/ActionDevtools.types";
+export declare const STATUS_COLOR: Record<TDevtoolsActionStatus, string>;
+export declare const STATUS_SYMBOL: Record<TDevtoolsActionStatus, string>;
+export declare function safeStringify(value: unknown, indent?: number): string;
+export declare function formatRelativeAge(ms: number): string;
+export declare function formatDuration(entry: IDevtoolsActionEntry): string | null;
+export declare function formatTimestamp(startTime: number): string;

package/build/types/devtools/browser/index.d.ts

@@ -0,0 +1,3 @@
+export type { IDevtoolsActionEntry, IDevtoolsObservableDomain, TDevtoolsActionStatus, TDevtoolsListener, } from "../core/ActionDevtools.types";
+export { ActionDevtoolsCore, type IActionDevtoolsCoreOptions } from "../core/ActionDevtoolsCore";
+export { type INiceActionDevtoolsProps, NiceActionDevtools } from "./NiceActionDevtools";