@nice-code/action 0.2.15 → 0.2.17

package/build/devtools/server/index.js

@@ -50,10 +50,18 @@ class ActionServerDevtools {
         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 } : {}
-          });
+          const result = update.response?.result;
+          if (result != null && !result.ok) {
+            this._log("action-error", actionPath, runningAction.cuid, {
+              ...duration != null ? { duration: `${duration}ms` } : {},
+              error: serializeError(result.error)
+            });
+          } else {
+            this._log("success", actionPath, runningAction.cuid, {
+              ...duration != null ? { duration: `${duration}ms` } : {},
+              ...this._options.logPayloads ? { output: result?.output } : {}
+            });
+          }
         } else if (finishType === "failed" /* failed */) {
           this._log("failed", actionPath, runningAction.cuid, {
             ...duration != null ? { duration: `${duration}ms` } : {},
@@ -120,6 +128,12 @@ function defaultConsoleLogger(message) {
   console.log(message);
 }
 // src/devtools/core/ActionDevtoolsCore.ts
+function serializeErrorForDisplay(error) {
+  if (error != null && typeof error === "object" && error.name === "NiceError" && typeof error.toJsonObject === "function") {
+    return error.toJsonObject();
+  }
+  return error;
+}
 function extractRouting(context) {
   return (context?.routing ?? []).map((item) => {
     const handler = item.handler;
@@ -169,6 +183,7 @@ class ActionDevtoolsCore {
           status: "running",
           startTime: time,
           input: runningAction.state?.request?.input,
+          inputHash: runningAction.state?.request?.inputHash,
           progressUpdates: [],
           meta: extractMeta(runningAction.context),
           parentCuid: runningAction.parentCuid,
@@ -191,16 +206,29 @@ class ActionDevtoolsCore {
           };
           const finishType = update.finishType;
           if (finishType === "success" /* success */) {
-            return { ...base, status: "success", output: update.response?.result?.output };
+            const result = update.response?.result;
+            const outputHash = update.response?.outputHash;
+            if (result != null && !result.ok) {
+              const rawError = result.error;
+              const errorStack2 = rawError instanceof Error ? rawError.stack : undefined;
+              return {
+                ...base,
+                status: "action-error",
+                outputHash,
+                error: serializeErrorForDisplay(rawError),
+                errorStack: errorStack2
+              };
+            }
+            return { ...base, status: "success", output: result?.output, outputHash };
           }
           if (finishType === "failed" /* failed */) {
             const rawError = update.error;
             const errorStack2 = rawError instanceof Error ? rawError.stack : undefined;
-            return { ...base, status: "failed", error: rawError, errorStack: errorStack2 };
+            return { ...base, status: "failed", error: serializeErrorForDisplay(rawError), errorStack: errorStack2 };
           }
           const abortReason = update.reason;
           const errorStack = abortReason instanceof Error ? abortReason.stack : undefined;
-          return { ...base, status: "aborted", abortReason, errorStack };
+          return { ...base, status: "aborted", abortReason: serializeErrorForDisplay(abortReason), errorStack };
         });
       }
     });

package/build/index.js

@@ -204,6 +204,28 @@ class ActionPayload extends ActionBase {
   }
 }
 
+// src/utils/hashPayloadData.ts
+function stableStringify(value) {
+  if (value === null || value === undefined)
+    return String(value);
+  if (typeof value !== "object")
+    return JSON.stringify(value) ?? "undefined";
+  if (Array.isArray(value))
+    return `[${value.map(stableStringify).join(",")}]`;
+  const keys = Object.keys(value).sort();
+  return "{" + keys.map((k) => `${JSON.stringify(k)}:${stableStringify(value[k])}`).join(",") + "}";
+}
+function fnv1a32(str) {
+  let hash = 2166136261;
+  for (let i = 0;i < str.length; i++) {
+    hash = (hash ^ str.charCodeAt(i)) * 16777619 >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+function hashPayloadData(data) {
+  return fnv1a32(stableStringify(data));
+}
+
 // src/ActionDefinition/Action/Payload/ActionPayload.types.ts
 var EActionPayloadType;
 ((EActionPayloadType2) => {
@@ -247,14 +269,18 @@ class ActionPayload_Progress extends ActionPayload {
 // src/ActionDefinition/Action/Payload/ActionPayload_Result.ts
 class ActionPayload_Result extends ActionPayload {
   result;
+  outputHash;
   constructor(params, result, data) {
     super(params.context, "result" /* result */, data);
     this.result = result;
+    this.outputHash = result.ok ? hashPayloadData(this.context.schema.serializeOutput(result.output)) : hashPayloadData(result.error.message);
   }
   toJsonObject() {
+    const wireResult = this.result.ok ? { ok: true, output: this.context.schema.serializeOutput(this.result.output) } : this.result;
     return {
       ...this.toBaseJsonObject(),
-      result: this.result
+      result: wireResult,
+      outputHash: this.outputHash
     };
   }
   toJsonString() {
@@ -271,10 +297,12 @@ class ActionPayload_Result extends ActionPayload {
 // src/ActionDefinition/Action/Payload/ActionPayload_Request.ts
 class ActionPayload_Request extends ActionPayload {
   input;
+  inputHash;
   _callSite;
   constructor(params, input, data) {
     super(params.context, "request" /* request */, data);
     this.input = input;
+    this.inputHash = hashPayloadData(this.context.schema.serializeInput(input));
   }
   successResult(...args) {
     const output = args[0];
@@ -293,7 +321,8 @@ class ActionPayload_Request extends ActionPayload {
   toJsonObject() {
     return {
       ...super.toBaseJsonObject(),
-      input: this.context.schema.serializeInput(this.input)
+      input: this.context.schema.serializeInput(this.input),
+      inputHash: this.inputHash
     };
   }
   toJsonString() {
@@ -421,6 +450,7 @@ class RunningAction {
       this._resolveResult = resolve;
       this._rejectResult = reject;
     });
+    this._resultPayloadPromise.catch(() => {});
     this._state = {
       request: initialState.request,
       progress: initialState.progress ?? [],
@@ -519,6 +549,20 @@ class RunningAction {
     });
     return true;
   }
+  _failWithError(error) {
+    if (this._state.result != null || this._isAborted)
+      return false;
+    this._isAborted = true;
+    this._rejectResult(error);
+    this._sendUpdate({
+      type: "finished" /* finished */,
+      finishType: "failed" /* failed */,
+      runningAction: this,
+      time: Date.now(),
+      error
+    });
+    return true;
+  }
   _updateProgress(progress) {
     if (this._state.result != null || this._isAborted)
       return;
@@ -540,6 +584,9 @@ class RunningAction {
     return this._completeWithResult(result);
   }
 }
+// src/ActionRuntime/Handler/Local/ActionLocalHandler.ts
+import { castNiceError as castNiceError2, isNiceErrorObject, NiceError } from "@nice-code/error";
+
 // src/errors/err_nice_action.ts
 import { err, err_nice } from "@nice-code/error";
 var EErrId_NiceAction;
@@ -637,6 +684,7 @@ var isActionPayload_Result_JsonObject = (obj) => {
 };
 
 // src/ActionRuntime/ActionRuntime.ts
+import { castNiceError } from "@nice-code/error";
 import { nanoid as nanoid2 } from "nanoid";
 
 // src/utils/getAssumedRuntimeEnvironment.ts
@@ -912,8 +960,18 @@ class ActionRuntime {
     return this.handleActionPayload(action);
   }
   async handleActionPayload(action, options) {
-    const handlerForAction = this.getHandlerForActionOrThrow(action, options);
     if (action.type === "request" /* request */) {
+      let handlerForAction;
+      try {
+        handlerForAction = this.getHandlerForActionOrThrow(action, options);
+      } catch (err2) {
+        const runningAction2 = new RunningAction({
+          context: action.context,
+          request: action
+        });
+        runningAction2._completeWithResult(action.errorResult(castNiceError(err2)));
+        return runningAction2;
+      }
       const runningAction = await handlerForAction.handleActionRequest(action, {
         ...options,
         targetLocalRuntime: this
@@ -1119,7 +1177,15 @@ class ActionLocalHandler extends ActionHandler {
       parentCuid: peekHandlerCuid(),
       callSite: action._callSite ?? new Error().stack
     });
-    this._handleRunningAction(handler, runningAction).catch((err2) => runningAction._abort(err2));
+    this._handleRunningAction(handler, runningAction).catch((err2) => {
+      if (err2 instanceof NiceError) {
+        runningAction._completeWithResult(action.errorResult(err2));
+      } else if (isNiceErrorObject(err2)) {
+        runningAction._completeWithResult(action.errorResult(castNiceError2(err2)));
+      } else {
+        runningAction._abort(err2);
+      }
+    });
     return runningAction;
   }
   async _handleRunningAction(handler, runningAction) {
@@ -1263,6 +1329,17 @@ class ActionDomain extends ActionDomainBase {
     }
     return new ActionCore(this, id);
   }
+  wrapAsPartialLocalHandler(wrappedActionExecutor) {
+    const _handler = new ActionLocalHandler;
+    const executor = wrappedActionExecutor;
+    for (const actionKey in wrappedActionExecutor) {
+      if (!this.actionSchema[actionKey]) {
+        continue;
+      }
+      _handler.forAction(this.actionForId(actionKey), (request) => executor[request.id](request.input));
+    }
+    return _handler;
+  }
   wrapAsLocalHandler(wrappedActionExecutor) {
     const _handler = new ActionLocalHandler;
     const executor = wrappedActionExecutor;
@@ -1331,7 +1408,11 @@ class ActionDomain extends ActionDomainBase {
       });
     }
     const contextAction = this.hydrateContext(id, serialized.context);
-    return new ActionPayload_Result({ context: contextAction }, serialized.result, {
+    const result = serialized.result.ok ? {
+      ok: true,
+      output: contextAction.schema.deserializeOutput(serialized.result.output)
+    } : serialized.result;
+    return new ActionPayload_Result({ context: contextAction }, result, {
       time: serialized.time
     });
   }
@@ -1508,9 +1589,22 @@ class ActionRootDomain extends ActionDomainBase {
     return this._actionRuntimeManager.getBestRuntimeForSpecifier(clientSpecifier);
   }
   async _runAction(actionPayload, options) {
-    const { handler, runtime: runtime2 } = this._actionRuntimeManager.getRuntimeAndHandlerForActionOrThrow(actionPayload, options);
-    actionPayload.context._setOriginClient(runtime2.coordinate);
     const allListeners = [...this._listeners, ...options?.listeners ?? []];
+    let handlerAndRuntime;
+    try {
+      handlerAndRuntime = this._actionRuntimeManager.getRuntimeAndHandlerForActionOrThrow(actionPayload, options);
+    } catch (err2) {
+      const runningAction2 = new RunningAction({
+        context: actionPayload.context,
+        request: actionPayload,
+        callSite: actionPayload._callSite
+      });
+      runningAction2.addUpdateListeners(allListeners);
+      runningAction2._failWithError(err2);
+      throw err2;
+    }
+    const { handler, runtime: runtime2 } = handlerAndRuntime;
+    actionPayload.context._setOriginClient(runtime2.coordinate);
     const runningAction = await handler.handleActionRequest(actionPayload, {
       targetLocalRuntime: runtime2
     });
@@ -1534,20 +1628,12 @@ class ActionSchema {
   get outputSchema() {
     return this.outputOptions?.schema;
   }
-  input(options, serialize, deserialize) {
-    if (serialize != null && deserialize != null) {
-      this.inputOptions = { ...options, serialization: { serialize, deserialize } };
-    } else {
-      this.inputOptions = options;
-    }
+  input(options) {
+    this.inputOptions = options;
     return this;
   }
-  output(options, serialize, deserialize) {
-    if (serialize != null && deserialize != null) {
-      this.outputOptions = { ...options, serialization: { serialize, deserialize } };
-    } else {
-      this.outputOptions = options;
-    }
+  output(options) {
+    this.outputOptions = options;
     return this;
   }
   throws(domain, ids) {
@@ -1877,7 +1963,7 @@ class TransportCustom extends Transport {
 }
 
 // src/ActionRuntime/Handler/ExternalClient/Transport/Http/TransportHttp.ts
-import { castNiceError, NiceError } from "@nice-code/error";
+import { castNiceError as castNiceError3, isNiceErrorObject as isNiceErrorObject2, NiceError as NiceError2 } from "@nice-code/error";
 class TransportHttp extends Transport {
   constructor(def) {
     super({
@@ -1929,8 +2015,12 @@ class TransportHttp extends Transport {
             const jsonData = await res.json();
             if (isActionPayload_Result_JsonObject(jsonData)) {
               runningAction._completeWithResult(action._domain.hydrateResultPayload(jsonData));
+            } else if (isNiceErrorObject2(jsonData)) {
+              runningAction._completeWithResult(action.errorResult(castNiceError3(jsonData)));
             } else {
-              runningAction._completeWithResult(action.errorResult(castNiceError(jsonData)));
+              runningAction._completeWithResult(action.errorResult(err_nice_transport.fromId("invalid_action_response" /* invalid_action_response */, {
+                actionId: action.id
+              })));
             }
           } catch (e) {
             throw err_nice_transport.fromId("send_failed" /* send_failed */, {
@@ -1969,7 +2059,7 @@ class TransportHttp extends Transport {
       if (timedOut) {
         throw err_nice_transport.fromId("timeout" /* timeout */, { timeout });
       }
-      if (err3 instanceof NiceError) {
+      if (err3 instanceof NiceError2) {
         throw err3;
       }
       throw err_nice_transport.fromId("send_failed" /* send_failed */, {

package/build/react-query/index.js

@@ -2,18 +2,36 @@
 import {
   useMutation
 } from "@tanstack/react-query";
+import { useRef } from "react";
 function useActionMutation(action, options) {
   const mutationOptions = options ?? {};
-  return useMutation({
-    mutationFn: (input) => action.request(input).runToOutput(),
+  const callSiteRef = useRef(undefined);
+  const result = useMutation({
+    mutationFn: (input) => {
+      const req = action.request(input);
+      req._callSite = callSiteRef.current;
+      callSiteRef.current = undefined;
+      return req.runToOutput();
+    },
     ...mutationOptions
   });
+  return {
+    ...result,
+    mutate: (...args) => {
+      callSiteRef.current = new Error().stack;
+      return result.mutate(...args);
+    },
+    mutateAsync: (...args) => {
+      callSiteRef.current = new Error().stack;
+      return result.mutateAsync(...args);
+    }
+  };
 }
 // src/react-query/hooks/useActionQuery.ts
 import {
   useQuery
 } from "@tanstack/react-query";
-import { useRef } from "react";
+import { useRef as useRef2 } from "react";
 function actionQueryKey(action, input) {
   if (input === undefined) {
     return ["nice-action", action.domain, action.allDomains, action.id];
@@ -30,7 +48,7 @@ function useActionQuery(action, ...args) {
     [options] = args;
   }
   const { enabled, ...queryOptions } = options ?? {};
-  const callSiteRef = useRef(new Error().stack);
+  const callSiteRef = useRef2(new Error().stack);
   return useQuery({
     queryKey: input != null ? actionQueryKey(action, input) : actionQueryKey(action),
     queryFn: () => {

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

@@ -87,6 +87,7 @@ export interface IActionPayload_Base_JsonObject<DT extends EActionPayloadType, D
 export interface IActionPayload_Request_JsonObject<DOM extends IActionDomain = IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends IActionPayload_Base_JsonObject<EActionPayloadType.request, DOM, ID> {
     type: EActionPayloadType.request;
     input: TInferInputFromSchema<DOM["actionSchema"][ID]>["SerdeInput"];
+    inputHash: string;
 }
 export interface IActionPayload_Progress_JsonObject<DOM extends IActionDomain = IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends IActionPayload_Base_JsonObject<EActionPayloadType.progress, DOM, ID> {
     type: EActionPayloadType.progress;
@@ -94,7 +95,8 @@ export interface IActionPayload_Progress_JsonObject<DOM extends IActionDomain =
 }
 export interface IActionPayload_Result_JsonObject<DOM extends IActionDomain = IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends IActionPayload_Base_JsonObject<EActionPayloadType.result, DOM, ID> {
     type: EActionPayloadType.result;
-    result: TActionResultOutcome<TInferOutputFromSchema<DOM["actionSchema"][ID]>["Output"], TInferActionError<DOM["actionSchema"][ID]>>;
+    result: TActionResultOutcome<TInferOutputFromSchema<DOM["actionSchema"][ID]>["SerdeOutput"], TInferActionError<DOM["actionSchema"][ID]>>;
+    outputHash: string;
 }
 /**
  *

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"];
+    readonly inputHash: string;
     _callSite?: string;
     constructor(params: {
         context: ActionContext<DOM, ID>;

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

@@ -7,6 +7,7 @@ import { EActionPayloadType, type IActionPayload_Result_JsonObject } from "./Act
 import { ActionPayload_Request } from "./ActionPayload_Request";
 export declare class ActionPayload_Result<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends ActionPayload<EActionPayloadType.result, DOM, ID> {
     readonly result: TActionResultOutcome<TInferOutputFromSchema<DOM["actionSchema"][ID]>["Output"], TInferActionError<DOM["actionSchema"][ID]>>;
+    readonly outputHash: string;
     constructor(params: {
         context: ActionContext<DOM, ID>;
     } | ActionPayload_Request<DOM, ID>, result: TActionResultOutcome<TInferOutputFromSchema<DOM["actionSchema"][ID]>["Output"], TInferActionError<DOM["actionSchema"][ID]>>, data: IActionPayload_Data_Base);

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

@@ -29,6 +29,7 @@ export declare class RunningAction<DOM extends IActionDomain, ID extends keyof D
     _sendUpdate(update: TRunningActionUpdate<DOM, ID>): void;
     _completeWithResult(result: ActionPayload_Result<DOM, ID>): boolean;
     _abort(reason?: unknown): boolean;
+    _failWithError(error: unknown): boolean;
     _updateProgress(progress: ActionPayload_Progress<DOM, ID>): void;
     waitForResultPayload(): Promise<ActionPayload_Result<DOM, ID>>;
     _resolveFromJson(resultJson: IActionPayload_Result_JsonObject<DOM, ID>): boolean;

package/build/types/ActionDefinition/Domain/ActionDomain.d.ts

@@ -1,6 +1,6 @@
+import type { ActionRuntime } from "../../ActionRuntime/ActionRuntime";
 import type { IExecuteActionOptions } from "../../ActionRuntime/Handler/ActionHandler.types";
 import { ActionLocalHandler } from "../../ActionRuntime/Handler/Local/ActionLocalHandler";
-import type { ActionRuntime } from "../../ActionRuntime/ActionRuntime";
 import type { TAction_Any_JsonObject, TDistributeActionPayload_Request, TDistributeActionPayload_Result, TDistributedDomainActions, TNarrowActionJsonTypeToActionInstanceType } from "../Action/Action.combined.types";
 import { type IActionBase } from "../Action/ActionBase.types";
 import { ActionContext } from "../Action/Context/ActionContext";
@@ -29,6 +29,7 @@ export declare class ActionDomain<ACT_DOM extends IActionDomain = IActionDomain>
     get action(): TActionMap<ACT_DOM>;
     actionsMap(): TActionMap<ACT_DOM>;
     actionForId<ID extends keyof ACT_DOM["actionSchema"] & string>(id: ID): ActionCore<ACT_DOM, ID>;
+    wrapAsPartialLocalHandler(wrappedActionExecutor: Partial<TWrappableDomainActionHandler<ACT_DOM>>): ActionLocalHandler;
     wrapAsLocalHandler(wrappedActionExecutor: TWrappableDomainActionHandler<ACT_DOM>): ActionLocalHandler;
     hydrateContext<ID extends keyof ACT_DOM["actionSchema"] & string>(id: ID, contextData: IActionContext_Data_JsonObject): ActionContext<ACT_DOM, ID>;
     isDomainAction<ACT extends IActionBase<any, ACT_DOM, any>>(action: ACT | unknown | null | undefined): action is TDistributedDomainActions<ACT_DOM, ACT>;

package/build/types/ActionDefinition/Domain/ActionRootDomain.d.ts

@@ -2,7 +2,7 @@ import type { ActionRuntime } from "../../ActionRuntime/ActionRuntime";
 import type { IExecuteActionOptions } from "../../ActionRuntime/Handler/ActionHandler.types";
 import type { IRuntimeCoordinate } from "../../ActionRuntime/RuntimeCoordinate";
 import type { ActionPayload_Request } from "../Action/Payload/ActionPayload_Request";
-import type { RunningAction } from "../Action/RunningAction";
+import { RunningAction } from "../Action/RunningAction";
 import { ActionDomain } from "./ActionDomain";
 import type { IActionDomain, IActionDomainChildOptions, IActionRootDomain, TActionDomainChildDef } from "./ActionDomain.types";
 import { ActionDomainBase } from "./ActionDomainBase";

package/build/types/ActionDefinition/Schema/ActionSchema.d.ts

@@ -13,30 +13,12 @@ export declare class ActionSchema<INPUT extends TTransportedValue<any, any> = ne
      * needing explicit type parameters.
      */
     input<VS extends StandardSchemaV1 = StandardSchemaV1, SERDE_IN = any>(options: TActionSchemaOptions<VS, SERDE_IN>): ActionSchema<TTransportedValue<StandardSchemaV1.InferInput<VS>, SERDE_IN>, OUTPUT, ERRORS>;
-    /**
-     * Declare the input schema with serialization via sequential parameters.
-     * TypeScript infers SERDE_IN from `serialize`'s return type (left-to-right),
-     * then provides it as the contextual type for `deserialize`'s parameter —
-     * no explicit type parameters or casts needed.
-     */
-    input<VS extends StandardSchemaV1, SERDE_IN = any>(options: {
-        schema: VS;
-    }, serialize: (raw: StandardSchemaV1.InferInput<VS>) => SERDE_IN, deserialize: (serde: SERDE_IN) => StandardSchemaV1.InferInput<VS>): ActionSchema<TTransportedValue<StandardSchemaV1.InferInput<VS>, SERDE_IN>, OUTPUT, ERRORS>;
     /**
      * Declare the output schema (JSON-native or with explicit SERDE type param).
      * For non-JSON-native outputs, prefer the 3-argument form below to avoid
      * needing explicit type parameters.
      */
     output<VS extends StandardSchemaV1 = StandardSchemaV1, SERDE_OUT = any>(options: TActionSchemaOptions<VS, SERDE_OUT>): ActionSchema<INPUT, TTransportedValue<StandardSchemaV1.InferInput<VS>, SERDE_OUT>, ERRORS>;
-    /**
-     * Declare the output schema with serialization via sequential parameters.
-     * TypeScript infers SERDE_OUT from `serialize`'s return type (left-to-right),
-     * then provides it as the contextual type for `deserialize`'s parameter —
-     * no explicit type parameters or casts needed.
-     */
-    output<VS extends StandardSchemaV1, SERDE_OUT = any>(options: {
-        schema: VS;
-    }, serialize: (raw: StandardSchemaV1.InferInput<VS>) => SERDE_OUT, deserialize: (serde: SERDE_OUT) => StandardSchemaV1.InferInput<VS>): ActionSchema<INPUT, TTransportedValue<StandardSchemaV1.InferInput<VS>, SERDE_OUT>, ERRORS>;
     /**
      * Declare that this action may throw any error from `domain`.
      * `TInferActionError` will include `NiceError<DEF, keyof schema>` in its union.

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

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

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

@@ -1,4 +1,6 @@
-export declare function ChildDispatchChips({ labels, size, }: {
-    labels?: string[];
-    size?: "sm" | "md";
+import type { IDevtoolsRouteItem } from "../../core/ActionDevtools.types";
+import { ESize } from "../ui_util/size";
+export declare function ChildDispatchChips({ childRouteItems, size, }: {
+    childRouteItems?: IDevtoolsRouteItem[];
+    size?: ESize;
 }): import("react/jsx-runtime").JSX.Element | null;

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

@@ -1,11 +1,23 @@
-import type { CSSProperties, ReactNode } from "react";
-interface IChipProps {
+import { type CSSProperties, type ReactNode } from "react";
+import { type ESemanticThing } from "../../core/devtools_colors";
+import { ESize } from "../ui_util/size";
+import { type ITooltipConfig } from "./Tooltip";
+export interface IChipColorEntry {
     color: string;
     borderColor: string;
-    fontSize?: string;
-    padding?: string;
+    subtle?: {
+        color?: string;
+        borderColor?: string;
+    };
+}
+interface IChipProps {
+    color: ESemanticThing;
+    subtle?: boolean;
+    size?: ESize;
+    rounded?: boolean;
+    tooltip?: ITooltipConfig;
     children: ReactNode;
     style?: CSSProperties;
 }
-export declare function Chip({ color, borderColor, fontSize, padding, children, style, }: IChipProps): import("react/jsx-runtime").JSX.Element;
+export declare function Chip({ color, subtle, size, rounded, tooltip, children, style, }: IChipProps): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -1,15 +1,7 @@
-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;
+import { ESize } from "../ui_util/size";
 export declare function DomainChip({ subtle, domain, allDomains, size, }: {
     subtle?: boolean;
     domain: string;
-    allDomains?: string[];
-    size: "sm" | "md";
+    allDomains: string[];
+    size?: ESize;
 }): import("react/jsx-runtime").JSX.Element;

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

@@ -1,8 +1,9 @@
 import type { IDevtoolsActionEntry, IDevtoolsRouteItem } from "../../core/ActionDevtools.types";
+import { ESize } from "../ui_util/size";
 export declare function getExternalLabel(hop: IDevtoolsRouteItem): string | null;
 interface IHandlerChipsProps {
     entry: IDevtoolsActionEntry;
-    size: "sm" | "md";
+    size: ESize;
 }
 export declare function HandlerChips({ entry, size }: IHandlerChipsProps): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -0,0 +1,15 @@
+import type { LucideIcon } from "lucide-react";
+import type { CSSProperties } from "react";
+import { type ESemanticThing } from "../../core/devtools_colors";
+import { ESize } from "../ui_util/size";
+import { type ITooltipConfig } from "./Tooltip";
+interface IIconProps {
+    icon: LucideIcon;
+    color: ESemanticThing;
+    size?: ESize;
+    subtle?: boolean;
+    tooltip?: ITooltipConfig;
+    style?: CSSProperties;
+}
+export declare function Icon({ icon: IconComponent, color, size, subtle, tooltip, style, }: IIconProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,19 @@
+export type TNiceErrorJson = {
+    name: "NiceError";
+    message: string;
+    ids: string[];
+    httpStatusCode: number;
+    def: {
+        domain: string;
+        allDomains: string[];
+    };
+};
+export declare function isNiceErrorJson(value: unknown): value is TNiceErrorJson;
+export declare function NiceErrorBody({ error }: {
+    error: TNiceErrorJson;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function NiceErrorDisplay({ error, label, color, }: {
+    error: TNiceErrorJson;
+    label: string;
+    color: string;
+}): import("react/jsx-runtime").JSX.Element;

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

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

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

@@ -0,0 +1,14 @@
+import type { ReactNode } from "react";
+export interface ITooltipConfig {
+    content: ReactNode;
+    title?: ReactNode;
+    /** "center" centers the tooltip above/below the anchor (default).
+     *  "edge" aligns the nearer horizontal edge with the anchor edge. */
+    align?: "center" | "edge";
+    maxWidth?: number;
+}
+export declare function Tooltip({ anchor, config, children, }: {
+    anchor: DOMRect;
+    config: ITooltipConfig;
+    children?: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/build/types/devtools/browser/components/{ActionDetailPanel.d.ts → action_detail/ActionDetailPanel.d.ts}

@@ -1,4 +1,4 @@
-import type { IDevtoolsActionEntry } from "../../core/ActionDevtools.types";
+import type { IDevtoolsActionEntry } from "../../../core/ActionDevtools.types";
 export declare function ActionDetailPanel({ entry, parent, childEntries, onSelectEntry, }: {
     entry: IDevtoolsActionEntry;
     parent: IDevtoolsActionEntry | null;