@nice-code/action 0.7.0 → 0.9.0

package/build/ActionPayload.types-D28ELKXC.d.ts

@@ -0,0 +1,2328 @@
+import { INiceErrorDomainProps, InferNiceError, NiceError, NiceErrorDomain, err_cast_not_nice } from "@nice-code/error";
+import { RuntimeName } from "std-env";
+import { ClientCryptoKeyLink, StorageAdapter, TSerializedCryptoKeyData_Ed25519_Raw, TSerializedCryptoKeyData_X25519_Raw, TTypeAndId } from "@nice-code/util";
+import * as v from "valibot";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/ActionDefinition/Schema/ActionSchema.types.d.ts
+type TTransportedValue<RAW_VAL, SERDE_VAL> = [RAW_VAL] | [RAW_VAL, SERDE_VAL];
+type TActionSerializationDefinition<RAW_VAL = any, SERDE_VAL = any> = {
+  serialize: (value: RAW_VAL) => SERDE_VAL;
+  deserialize: (value: SERDE_VAL) => RAW_VAL;
+};
+type TActionSchemaOptions<VS extends StandardSchemaV1 = StandardSchemaV1, SERDE_IN = any> = {
+  schema: VS;
+  serialization?: TActionSerializationDefinition<StandardSchemaV1.InferInput<VS>, SERDE_IN>;
+};
+/**
+ * One error declaration on an action schema.
+ * `IDS` is the subset of error IDs that may be thrown. When the full
+ * `keyof schema` union is used it means any ID from the domain can be thrown.
+ *
+ * Build via `action().throws(domain)` or `action().throws(domain, ids)`.
+ */
+interface IActionErrorDeclaration<ERR_DEF extends INiceErrorDomainProps = INiceErrorDomainProps, IDS extends keyof ERR_DEF["schema"] & string = keyof ERR_DEF["schema"] & string> {
+  readonly _domain: NiceErrorDomain<ERR_DEF>;
+  /** The specific IDs constrained for this declaration, or `undefined` meaning the full domain. */
+  readonly _ids: ReadonlyArray<IDS & string> | undefined;
+}
+/** @internal Maps a single INiceActionErrorDeclaration to its NiceError type. */
+type TInferErrorFromDeclaration<D> = D extends IActionErrorDeclaration<infer DEF, infer IDS> ? NiceError<DEF, IDS> : never;
+/**
+ * Union of all `NiceError` types that can be thrown from a tuple of error declarations.
+ * Distributes over each declaration and unions the results.
+ */
+type TInferDeclaredErrors<DECLS extends readonly IActionErrorDeclaration[]> = TInferErrorFromDeclaration<DECLS[number]>;
+//#endregion
+//#region src/ActionDefinition/Schema/ActionSchema.d.ts
+declare class ActionSchema<INPUT extends TTransportedValue<any, any> = never, OUTPUT extends TTransportedValue<any, any> = never, ERRORS extends readonly IActionErrorDeclaration<any, any>[] = readonly []> {
+  private _errorDeclarations;
+  private inputOptions;
+  private outputOptions;
+  get inputSchema(): StandardSchemaV1 | undefined;
+  get outputSchema(): StandardSchemaV1 | undefined;
+  /**
+   * Declare the input schema (JSON-native or with explicit SERDE type param).
+   * For non-JSON-native inputs, prefer the 3-argument form below to avoid
+   * 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 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 that this action may throw any error from `domain`.
+   * `TInferActionError` will include `NiceError<DEF, keyof schema>` in its union.
+   */
+  throws<ERR_DEF extends INiceErrorDomainProps>(domain: NiceErrorDomain<ERR_DEF>): ActionSchema<INPUT, OUTPUT, readonly [...ERRORS, IActionErrorDeclaration<ERR_DEF, keyof ERR_DEF["schema"] & string>]>;
+  /**
+   * Declare that this action may throw only the listed `ids` from `domain`.
+   * `TInferActionError` will include `NiceError<DEF, IDS[number]>` narrowed to those IDs.
+   */
+  throws<ERR_DEF extends INiceErrorDomainProps, IDS extends ReadonlyArray<keyof ERR_DEF["schema"] & string>>(domain: NiceErrorDomain<ERR_DEF>, ids: IDS): ActionSchema<INPUT, OUTPUT, readonly [...ERRORS, IActionErrorDeclaration<ERR_DEF, IDS[number] & string>]>;
+  /**
+   * Serialize raw input to a JSON-serializable form.
+   * Uses the schema's serialization.serialize if defined; otherwise the input
+   * is already JSON-native and is returned as-is.
+   */
+  serializeInput(rawInput: INPUT[0]): INPUT[1];
+  /**
+   * Deserialize a JSON value back into the raw input type.
+   * Uses serialization.deserialize if defined; otherwise the value is cast
+   * directly (it's already in the correct shape).
+   */
+  deserializeInput(serialized: INPUT[1]): INPUT[0];
+  /**
+   * Validate raw input against the schema defined via `.input({ schema })`.
+   * Throws `action_input_validation_failed` if validation fails.
+   * Returns the validated (and possibly coerced) value on success.
+   * If no input schema was declared, the value is passed through as-is.
+   */
+  validateInput(value: unknown, meta: {
+    domain: string;
+    actionId: string;
+  }): INPUT[0];
+  validateOutput(value: unknown, meta: {
+    domain: string;
+    actionId: string;
+  }): OUTPUT[0];
+  /**
+   * Serialize raw output to a JSON-serializable form.
+   */
+  serializeOutput(rawOutput: OUTPUT[0]): OUTPUT[1];
+  /**
+   * Deserialize a JSON value back into the raw output type.
+   */
+  deserializeOutput(serialized: OUTPUT[1]): OUTPUT[0];
+}
+type TInferActionError<SCH> = SCH extends ActionSchema<any, any, infer DECLS> ? DECLS extends readonly IActionErrorDeclaration[] ? TInferDeclaredErrors<DECLS> | InferNiceError<typeof err_cast_not_nice> : InferNiceError<typeof err_cast_not_nice> : never;
+declare const actionSchema: () => ActionSchema;
+//#endregion
+//#region src/ActionDefinition/Domain/ActionDomain.types.d.ts
+type TPossibleDomainId = string;
+type TPossibleDomainIdList = [...TPossibleDomainId[], TPossibleDomainId];
+type TActionDomainSchema = Record<string, ActionSchema<TTransportedValue<any, any>, TTransportedValue<any, any>, readonly IActionErrorDeclaration<any, any>[]>>;
+/**
+ * Data shape for a domain — used for construction and as the type-level schema carrier.
+ * Does NOT include class methods.
+ */
+interface IActionDomain<IDS extends TPossibleDomainIdList = TPossibleDomainIdList, SCH extends TActionDomainSchema = TActionDomainSchema> {
+  domain: IDS[0] & string;
+  allDomains: IDS;
+  actionSchema: SCH;
+}
+interface IActionRootDomain<ID extends TPossibleDomainId = TPossibleDomainId> extends IActionDomain<[ID], {}> {
+  domain: ID;
+  allDomains: [ID];
+  actionSchema: {};
+}
+interface IActionDomainChildOptions<ERR_DOMAIN extends string = string, SCHEMA extends TActionDomainSchema = TActionDomainSchema> {
+  domain: ERR_DOMAIN;
+  actions: SCHEMA;
+}
+type TActionDomainChildDef<PARENT_DEF extends IActionDomain, SUB extends IActionDomainChildOptions> = {
+  domain: SUB["domain"];
+  allDomains: [...PARENT_DEF["allDomains"], SUB["domain"]];
+  actionSchema: SUB["actions"];
+};
+type TDomainActionId<DOM extends IActionDomain> = keyof DOM["actionSchema"] & string;
+type TInferInputFromSchema<SCH extends ActionSchema<any, any, any>> = SCH extends ActionSchema<infer IN, any, any> ? {
+  Input: IN[0];
+  SerdeInput: IN[1];
+} : {
+  Input: never;
+  SerdeInput: never;
+};
+type TInferOutputFromSchema<SCH extends ActionSchema<any, any, any>> = SCH extends ActionSchema<any, infer OUT, any> ? {
+  Output: OUT[0];
+  SerdeOutput: OUT[1];
+} : never;
+type TWrappableDomainActionHandler<DOM extends IActionDomain> = { [K in TDomainActionId<DOM>]: (...args: [TInferInputFromSchema<DOM["actionSchema"][K]>["Input"]] extends [never] ? [] : [input: TInferInputFromSchema<DOM["actionSchema"][K]>["Input"]]) => [TInferOutputFromSchema<DOM["actionSchema"][K]>["Output"]] extends [never] ? Promise<void> | void : Promise<TInferOutputFromSchema<DOM["actionSchema"][K]>["Output"]> };
+//#endregion
+//#region src/ActionRuntime/RuntimeCoordinate.d.ts
+interface IRuntimeCoordinateSpecifics {
+  /**
+   * A unique and persistent client ID (should stay the same between runtime instance reloads)
+   */
+  perId?: string;
+  /**
+   * A unique instance (or "memory-only") ID (unique for each instance of an action runtime, which should generally
+   * not persist between reloads, depending on the architecture)
+   */
+  insId?: string;
+}
+interface IRuntimeCoordinate extends IRuntimeCoordinateSpecifics {
+  /**
+   * A static runtime environment identifier (e.g. "web_app_v1", "backend_analytics")
+   */
+  envId: string;
+}
+type TRuntimeCoordinateEnvId = `envId[${string}]`;
+type TRuntimeCoordinateStringId = `${TRuntimeCoordinateEnvId}perId[${string | "_"}]:insId[${string | "_"}]`;
+interface IRuntimeFullCoordinates extends Required<IRuntimeCoordinate> {}
+declare class RuntimeCoordinate implements IRuntimeCoordinate {
+  readonly envId: string;
+  readonly perId?: string;
+  readonly insId?: string;
+  static get unknown(): RuntimeCoordinate;
+  static env(envId: string): RuntimeCoordinate;
+  withPersistentId(perId: string): RuntimeCoordinate;
+  constructor({
+    envId,
+    perId,
+    insId
+  }: IRuntimeCoordinate);
+  specify(specifics: IRuntimeCoordinateSpecifics): RuntimeCoordinate;
+  specifyIfUnset(specifics: IRuntimeCoordinateSpecifics): RuntimeCoordinate;
+  toJsonObject(): IRuntimeCoordinate;
+  isExactlySame(other: IRuntimeCoordinate): boolean;
+  isSameFor(other: IRuntimeCoordinate): {
+    id: boolean;
+    perId: boolean;
+    insId: boolean;
+  };
+  similarityLevel(other: IRuntimeCoordinate): number;
+  get stringId(): TRuntimeCoordinateStringId;
+  /**
+   * Takes the "Runtime Coordinate" and generates a list of full coordinate IDs representing the runtime
+   * with decreasing levels of specificity.
+   *
+   * The first full coordinate ID is the most specific (including instance ID), while the last ID is
+   * the least specific (only environment ID).
+   *
+   * Example output for a RuntimeCoordinate with envId "web_app", perId "user123", and insId "instance456":
+   * [
+   *   "envId[web_app]perId[user123]:insId[instance456]",
+   *   "envId[web_app]perId[user123]:insId[_]",
+   *   "envId[web_app]perId[_]:insId[_]"
+   * ]
+   *
+   * @returns a list of "full" runtime coordinate IDs with decreasing accuracy for targeting a runtime.
+   */
+  toStringIds(): TRuntimeCoordinateStringId[];
+}
+//#endregion
+//#region src/ActionDefinition/Action/ActionBase.types.d.ts
+declare enum EActionForm {
+  core = "core",
+  context = "context",
+  data = "data"
+}
+interface INiceActionIdAndDomain<DOM extends IActionDomain = IActionDomain> {
+  domain: DOM["domain"];
+  id: keyof DOM["actionSchema"] & string;
+}
+interface IActionBase<FORM extends EActionForm, DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends INiceActionIdAndDomain<DOM> {
+  id: ID;
+  form: FORM;
+  _domain: ActionDomain<DOM>;
+  allDomains: DOM["allDomains"];
+  schema: DOM["actionSchema"][ID];
+}
+interface IActionBase_JsonObject<FORM extends EActionForm = EActionForm, DOM extends IActionDomain = IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> {
+  form: FORM;
+  domain: DOM["domain"];
+  allDomains: DOM["allDomains"];
+  id: ID;
+}
+//#endregion
+//#region src/ActionDefinition/Action/ActionBase.d.ts
+declare abstract class ActionBase<FORM extends EActionForm, DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> implements IActionBase<FORM, DOM, ID> {
+  readonly form: FORM;
+  readonly _domain: ActionDomain<DOM>;
+  readonly id: ID;
+  readonly domain: DOM["domain"];
+  readonly allDomains: DOM["allDomains"];
+  readonly schema: DOM["actionSchema"][ID];
+  constructor(form: FORM, _domain: ActionDomain<DOM>, id: ID);
+  protected toJsonObject(): IActionBase_JsonObject<FORM, DOM, ID>;
+  protected toJsonString(): string;
+}
+//#endregion
+//#region src/ActionDefinition/Action/Context/ActionContext.types.d.ts
+interface IActionRouteItem {
+  runtime: RuntimeCoordinate;
+  handler: IActionRouteItemHandler;
+  time: number;
+}
+interface IActionContext_Data {
+  cuid: string;
+  timeCreated: number;
+  routing: IActionRouteItem[];
+  originClient: RuntimeCoordinate;
+}
+interface IActionContext<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends IActionBase<EActionForm.context, DOM, ID>, IActionContext_Data {}
+/**
+ *
+ *  JSON TYPES
+ *
+ */
+interface IActionRouteItem_JsonObject {
+  runtime: IRuntimeCoordinate;
+  handler: IActionRouteItemHandler;
+  time: number;
+}
+interface IActionContext_Data_JsonObject {
+  cuid: string;
+  timeCreated: number;
+  routing: IActionRouteItem_JsonObject[];
+  originClient: IRuntimeCoordinate;
+}
+interface IActionContext_JsonObject<DOM extends IActionDomain = IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends IActionBase_JsonObject<EActionForm.context, DOM, ID>, IActionContext_Data_JsonObject {}
+//#endregion
+//#region src/ActionDefinition/Action/Context/ActionContext.d.ts
+declare class ActionContext<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends ActionBase<EActionForm.context, DOM, ID> implements IActionContext<DOM, ID> {
+  readonly _domain: ActionDomain<DOM>;
+  readonly form = EActionForm.context;
+  readonly _routing: IActionRouteItem[];
+  readonly timeCreated: number;
+  readonly cuid: string;
+  originClient: RuntimeCoordinate;
+  constructor(_domain: ActionDomain<DOM>, id: ID, hydrationData: IActionContext_Data);
+  _setOriginClient(client: RuntimeCoordinate): void;
+  toJsonString(): string;
+  toContextDataJsonObject(): IActionContext_Data_JsonObject;
+  toJsonObject(): IActionContext_JsonObject<DOM, ID>;
+  get routing(): IActionRouteItem[];
+  addRouteItem(item: IActionRouteItem): void;
+  deserializeInput(serialized: TInferInputFromSchema<DOM["actionSchema"][ID]>["SerdeInput"]): TInferInputFromSchema<DOM["actionSchema"][ID]>["Input"];
+  serializeInput(raw: TInferInputFromSchema<DOM["actionSchema"][ID]>["Input"]): TInferInputFromSchema<DOM["actionSchema"][ID]>["SerdeInput"];
+  validateInput(input: unknown): TInferInputFromSchema<DOM["actionSchema"][ID]>["Input"];
+  validateOutput(output: unknown): TInferOutputFromSchema<DOM["actionSchema"][ID]>["Output"];
+}
+//#endregion
+//#region src/ActionDefinition/Action/Payload/ActionPayload.d.ts
+declare abstract class ActionPayload<DT extends EActionPayloadType, DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends ActionBase<EActionForm.data, DOM, ID> implements IActionPayload_Base<DT, DOM, ID> {
+  readonly form: EActionForm.data;
+  readonly type: DT;
+  readonly context: ActionContext<DOM, ID>;
+  readonly time: number;
+  protected constructor(context: ActionContext<DOM, ID>, type: DT, data: IActionPayload_Data_Base);
+  protected toBaseJsonObject(): IActionPayload_Base_JsonObject<DT, DOM, ID>;
+  abstract toJsonObject(): IActionPayload_Base_JsonObject<DT, DOM, ID>;
+}
+//#endregion
+//#region src/ActionDefinition/Action/Payload/ActionPayload_Result.d.ts
+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);
+  toJsonObject(): IActionPayload_Result_JsonObject<DOM, ID>;
+  toJsonString(): string;
+  toHttpResponse({
+    useErrorStatus
+  }?: {
+    useErrorStatus?: boolean;
+  }): Response;
+}
+//#endregion
+//#region src/ActionDefinition/Action/RunningAction.types.d.ts
+declare enum ERunningActionState {
+  running = "running",
+  completed = "completed"
+}
+interface IRunningActionState<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string> {
+  request: ActionPayload_Request<DOM, ID>;
+  progress: ActionPayload_Progress<DOM, ID>[];
+  result?: ActionPayload_Result<DOM, ID>;
+}
+interface IRunningActionState_ConstructorParams<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string> {
+  context: ActionContext<DOM, ID>;
+  request: ActionPayload_Request<DOM, ID>;
+  progress?: ActionPayload_Progress<DOM, ID>[];
+  result?: ActionPayload_Result<DOM, ID>;
+  parentCuid?: string;
+  callSite?: string;
+}
+declare enum ERunningActionUpdateType {
+  started = "started",
+  progress = "progress",
+  finished = "finished"
+}
+interface IRunningActionEvent_Base<T extends ERunningActionUpdateType, DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> {
+  type: T;
+  runningAction: RunningAction<DOM, ID>;
+  time: number;
+}
+interface IRunningActionUpdate_Started<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends IRunningActionEvent_Base<ERunningActionUpdateType.started, DOM, ID> {}
+interface IRunningActionUpdate_Progress<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends IRunningActionEvent_Base<ERunningActionUpdateType.progress, DOM, ID> {
+  progress: TActionProgress;
+}
+declare enum ERunningActionFinishedType {
+  aborted = "aborted",
+  failed = "failed",
+  success = "success"
+}
+interface IRunningActionUpdate_Finished<FT extends ERunningActionFinishedType, DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends IRunningActionEvent_Base<ERunningActionUpdateType.finished, DOM, ID> {
+  finishType: FT;
+  reason?: unknown;
+}
+interface IRunningActionUpdate_Abort<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends IRunningActionUpdate_Finished<ERunningActionFinishedType.aborted, DOM, ID> {
+  reason?: unknown;
+}
+interface IRunningActionUpdate_Failed<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends IRunningActionUpdate_Finished<ERunningActionFinishedType.failed, DOM, ID> {
+  error: TInferActionError<DOM["actionSchema"][ID]>;
+}
+interface IRunningActionUpdate_Success<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends IRunningActionUpdate_Finished<ERunningActionFinishedType.success, DOM, ID> {
+  response: ActionPayload_Result<DOM, ID>;
+}
+type TRunningActionUpdateFinished<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> = IRunningActionUpdate_Abort<DOM, ID> | IRunningActionUpdate_Failed<DOM, ID> | IRunningActionUpdate_Success<DOM, ID>;
+type TRunningActionUpdate<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> = IRunningActionUpdate_Started<DOM, ID> | IRunningActionUpdate_Progress<DOM, ID> | TRunningActionUpdateFinished<DOM, ID>;
+type TRunningActionUpdateListener<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> = (update: TRunningActionUpdate<DOM, ID>) => void;
+/**
+ * Distributes a union ID into a proper discriminated union of RunningAction update events,
+ * so that narrowing on `update.runningAction.id` also narrows `update.runningAction`'s input/output types.
+ */
+type TDistributeRunningActionUpdate<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> = ID extends keyof DOM["actionSchema"] & string ? TRunningActionUpdate<DOM, ID> : never;
+type TDistributeRunningActionUpdateListener<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> = (update: TDistributeRunningActionUpdate<DOM, ID>) => void;
+interface IRunningActionUserMethods<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string> {
+  waitForResultPayload(): Promise<ActionPayload_Result<DOM, ID>>;
+  addUpdateListeners(listeners: TRunningActionUpdateListener<DOM, ID>[]): () => void;
+  iterateUpdates(): AsyncIterable<TRunningActionUpdate<DOM, ID>>;
+  abort(reason?: unknown): void;
+}
+//#endregion
+//#region src/ActionDefinition/Action/Core/ActionCore.types.d.ts
+interface IActionCore<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends IActionBase<EActionForm.core, DOM, ID> {}
+type IActionCore_JsonObject<DOM extends IActionDomain = IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> = {
+  form: EActionForm.core;
+  domain: DOM["domain"];
+  allDomains: DOM["allDomains"];
+  id: ID;
+};
+//#endregion
+//#region src/ActionDefinition/Action/Action.combined.types.d.ts
+/**
+ * Distributes a union ID into a proper discriminated union of ActionPayload_Request instances,
+ * so that narrowing on `.id` also narrows `.input`.
+ */
+type TDistributeActionPayload_Request<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string> = ID extends keyof DOM["actionSchema"] & string ? ActionPayload_Request<DOM, ID> : never;
+/**
+ * Distributes a union ID into a proper discriminated union of ActionPayload_Result instances,
+ * so that narrowing on `.id` also narrows `.result`.
+ */
+type TDistributeActionPayload_Result<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string> = ID extends keyof DOM["actionSchema"] & string ? ActionPayload_Result<DOM, ID> : never;
+/**
+ *
+ *  COMBINED JSON TYPES
+ *
+ */
+type TAction_Any_JsonObject<DOM extends IActionDomain = IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> = IActionCore_JsonObject<DOM, ID> | TActionPayload_Any_JsonObject<DOM, ID> | IActionContext_JsonObject<DOM, ID>;
+/**
+ *
+ *  UTILITY TYPES
+ *
+ */
+type TDistributedDomainActions<DOM extends IActionDomain, ACT extends IActionBase<any, DOM, any>> = { [ID in keyof DOM["actionSchema"] & string]: TNarrowActionType<DOM, ACT, ID> }[keyof DOM["actionSchema"] & string];
+type TNarrowActionType<DOM extends IActionDomain, ACT extends IActionBase<any, DOM, any>, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> = ACT extends ActionPayload_Result<any> ? ActionPayload_Result<DOM, ID> : ACT extends ActionPayload_Request<any> ? ActionPayload_Request<DOM, ID> : ACT extends ActionPayload_Progress<any> ? ActionPayload_Progress<DOM, ID> : ACT extends ActionCore<any> ? ActionCore<DOM, ID> : never;
+type TNarrowActionJsonTypeToActionInstanceType<DOM extends IActionDomain, ACT extends TAction_Any_JsonObject<DOM>, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> = ACT extends IActionPayload_Request_JsonObject<any> ? ActionPayload_Request<DOM, ID> : ACT extends IActionPayload_Result_JsonObject<any> ? ActionPayload_Result<DOM, ID> : ACT extends IActionPayload_Progress_JsonObject<any> ? ActionPayload_Progress<DOM, ID> : ACT extends IActionCore_JsonObject<any> ? ActionCore<DOM, ID> : never;
+//#endregion
+//#region src/ActionRuntime/ActionDomainManager.d.ts
+declare class ActionDomainManager {
+  private _domains;
+  addDomain(domain: ActionDomain<any>): void;
+  getDomains(): ActionDomain<any>[];
+  verifyIsActionJson(action: INiceActionIdAndDomain<any>): void;
+  getActionDomain<DOM extends IActionDomain, ACT extends INiceActionIdAndDomain<DOM>>(action: ACT): ActionDomain<DOM> | undefined;
+  getActionDomainOrThrow<DOM extends IActionDomain, ACT extends INiceActionIdAndDomain<DOM>>(action: ACT): ActionDomain<DOM>;
+  hydrateActionPayload<D extends IActionDomain, ID extends keyof D["actionSchema"] & string, A extends TAction_Any_JsonObject<D, ID>>(actionJson: A): TNarrowActionJsonTypeToActionInstanceType<D, A, ID>;
+}
+//#endregion
+//#region src/ActionRuntime/Routing/ActionRouter.types.d.ts
+/**
+ * Format: `dom[${domainName}]id[${actionId | "_"}]`
+ * The wildcard `_` matches any action ID within a domain.
+ */
+type TMatchHandlerKey = `${"dom"}[${string}]id[${string | "_"}]`;
+declare enum EActionRouterContextType {
+  runtime_to_handler = "runtime_to_handler",
+  handler_route = "handler_route"
+}
+interface IActionRouterContext_HandlerRoute {
+  contextType: EActionRouterContextType.handler_route;
+  handler: TActionHandler;
+}
+interface IActionRouterContext_RuntimeToHandler {
+  contextType: EActionRouterContextType.runtime_to_handler;
+  runtime: ActionRuntime;
+}
+type IActionRouterContext = IActionRouterContext_HandlerRoute | IActionRouterContext_RuntimeToHandler;
+//#endregion
+//#region src/ActionRuntime/Routing/ActionRouter.d.ts
+declare class ActionRouter<DATA> {
+  readonly domainManager: ActionDomainManager;
+  private actionRouteData;
+  private _context;
+  constructor(context: IActionRouterContext);
+  /** Copy all routes from another router into this one, replacing any overlapping keys. */
+  mergeRouter(actionRouter: ActionRouter<DATA>): void;
+  addDomainsFromOther(actionRouter: ActionRouter<DATA>): void;
+  /** All FNs registered for an action, ID-specific entries first then domain wildcard. */
+  getRouteDataEntriesForAction(action: {
+    domain: string;
+    id: string;
+  }): DATA[];
+  /** First FN registered for an action (ID-specific beats domain wildcard). */
+  getRouteDataForAction(action: INiceActionIdAndDomain): DATA | undefined;
+  private throwNoHandlerForAction;
+  getRouteDataEntriesForActionOrThrow(action: INiceActionIdAndDomain, context: IHandleActionOptions): DATA[];
+  getRouteDataForActionOrThrow(action: INiceActionIdAndDomain, context: IHandleActionOptions): DATA;
+  /** All FNs stored under an exact match key. */
+  getForKey(key: TMatchHandlerKey): readonly DATA[];
+  /** Every match key that has at least one registered FN. */
+  getRegisteredKeys(): TMatchHandlerKey[];
+  getDomains(): ActionDomain[];
+  /** Register a handler for all actions in a domain, replacing any existing one. */
+  forDomain<FOR_DOM extends IActionDomain>(domain: ActionDomain<FOR_DOM>, routeData: DATA): this;
+  forAction<ACT_DOM extends IActionDomain, ID extends keyof ACT_DOM["actionSchema"] & string>(action: ActionCore<ACT_DOM, ID>, routeData: DATA): this;
+  /** Register a handler for a specific action, replacing any existing one. */
+  forActionId<ACT_DOM extends IActionDomain, ID extends keyof ACT_DOM["actionSchema"] & string>(domain: ActionDomain<ACT_DOM>, id: ID, routeData: DATA): this;
+  /** Register one handler for several action IDs, replacing any existing ones. */
+  forActionIds<ACT_DOM extends IActionDomain, IDS extends ReadonlyArray<keyof ACT_DOM["actionSchema"] & string>>(domain: ActionDomain<ACT_DOM>, ids: IDS, routeData: DATA): this;
+  /** Register per-action handlers from a cases map, replacing any existing ones. */
+  forDomainActionCases<FOR_DOM extends IActionDomain>(domain: ActionDomain<FOR_DOM>, cases: { [ID in keyof FOR_DOM["actionSchema"] & string]?: DATA }): this;
+  /** Append a handler for all actions in a domain (accumulates alongside existing). */
+  addForDomain<FOR_DOM extends IActionDomain>(domain: ActionDomain<FOR_DOM>, routeData: DATA): this;
+  /** Append a handler for a specific action (accumulates alongside existing). */
+  addForAction<ACT_DOM extends IActionDomain, ID extends keyof ACT_DOM["actionSchema"] & string>(domain: ActionDomain<ACT_DOM>, id: ID, routeData: DATA): this;
+  /** Append one handler for several action IDs (accumulates alongside existing). */
+  addForActionIds<ACT_DOM extends IActionDomain, IDS extends ReadonlyArray<keyof ACT_DOM["actionSchema"] & string>>(domain: ActionDomain<ACT_DOM>, ids: IDS, routeData: DATA): this;
+  /** Append per-action handlers from a cases map (accumulates alongside existing). */
+  addForDomainActionCases<FOR_DOM extends IActionDomain>(domain: ActionDomain<FOR_DOM>, cases: { [ID in keyof FOR_DOM["actionSchema"] & string]?: DATA }): this;
+  /** Append a handler directly by its raw match key (used when the key is known ahead of time). */
+  addForKey(key: TMatchHandlerKey, routeData: DATA): this;
+  private _push;
+}
+//#endregion
+//#region src/ActionRuntime/Handler/ActionHandler.types.d.ts
+declare enum EActionHandlerType {
+  external = "external",
+  local = "local"
+}
+interface IActionHandler_Json<T extends EActionHandlerType> {
+  type: T;
+}
+interface IActionHandler_ExternalClient_Json extends IActionHandler_Json<EActionHandlerType.external> {
+  client: IRuntimeCoordinate;
+}
+interface IActionHandler_Local_Json extends IActionHandler_Json<EActionHandlerType.local> {}
+type TActionHandler_Json = IActionHandler_Local_Json | IActionHandler_ExternalClient_Json;
+interface IHandleActionOptions {
+  timeout?: number;
+  targetExternalClient?: RuntimeCoordinate;
+  targetLocalRuntime?: ActionRuntime;
+}
+interface IExecuteActionOptions<DOM extends IActionDomain = IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends IHandleActionOptions {
+  listeners?: TRunningActionUpdateListener<DOM, ID>[];
+}
+interface IActionHandler_Base<T extends EActionHandlerType> {
+  cuid: string;
+  handlerType: T;
+  getActionRouter: () => ActionRouter<any>;
+}
+/**
+ *
+ *  LOCAL ACTION HANDLER
+ *
+ */
+interface IHandleActionOptions_Local extends IHandleActionOptions {}
+interface IActionHandler_Local extends IActionHandler_Base<EActionHandlerType.local> {
+  handleActionRequest: <DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string>(action: ActionPayload_Request<DOM, ID>, config?: IHandleActionOptions_Local) => Promise<RunningAction<DOM, ID>>;
+}
+/**
+ *
+ *  EXTERNAL CLIENT ACTION HANDLER
+ *
+ */
+interface IHandleActionOptions_External extends IHandleActionOptions {}
+interface IActionHandler_ExternalClient extends IActionHandler_Base<EActionHandlerType.external> {
+  externalClient: RuntimeCoordinate;
+  handleActionRequest: <DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string>(action: ActionPayload_Request<DOM, ID>, config?: IHandleActionOptions_External) => Promise<RunningAction<DOM, ID>>;
+  _setIncomingActionDataListener(listener: (json: TActionPayload_Any_JsonObject<any>) => void): void;
+}
+/**
+ *
+ *  COMBINED
+ *
+ */
+type TActionHandler = IActionHandler_Local | IActionHandler_ExternalClient;
+//#endregion
+//#region src/ActionDefinition/Action/Payload/ActionPayload_Request.d.ts
+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>;
+  }, input: TInferInputFromSchema<DOM["actionSchema"][ID]>["Input"], data: IActionPayload_Data_Base);
+  successResult(...args: [TInferOutputFromSchema<DOM["actionSchema"][ID]>["Output"]] extends [never] ? [] | [output: TInferOutputFromSchema<DOM["actionSchema"][ID]>["Output"]] : [output: TInferOutputFromSchema<DOM["actionSchema"][ID]>["Output"]]): ActionPayload_Result<DOM, ID>;
+  errorResult(err: TInferActionError<DOM["actionSchema"][ID]>): ActionPayload_Result<DOM, ID>;
+  progress(progress: TActionProgress): ActionPayload_Progress<DOM, ID>;
+  toJsonObject(): IActionPayload_Request_JsonObject<DOM, ID>;
+  toJsonString(): string;
+  runToOutput(options?: IExecuteActionOptions<DOM, ID>): Promise<TInferOutputFromSchema<DOM["actionSchema"][ID]>["Output"]>;
+  runToResultPayload(options?: IExecuteActionOptions<DOM, ID>): Promise<ActionPayload_Result<DOM, ID>>;
+  run(options?: IExecuteActionOptions<DOM, ID>): Promise<RunningAction<DOM, ID>>;
+}
+//#endregion
+//#region src/ActionDefinition/Action/Payload/ActionPayload_Progress.d.ts
+declare class ActionPayload_Progress<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends ActionPayload<EActionPayloadType.progress, DOM, ID> implements IActionPayload_Progress<DOM, ID> {
+  readonly progress: TActionProgress;
+  constructor(params: {
+    context: ActionContext<DOM, ID>;
+  } | ActionPayload_Request<DOM, ID>, progress: TActionProgress, data: IActionPayload_Data_Base);
+  toJsonObject(): IActionPayload_Progress_JsonObject<DOM, ID>;
+  toJsonString(): string;
+  toHttpResponse(): Response;
+}
+//#endregion
+//#region src/ActionDefinition/Action/RunningAction.d.ts
+declare class RunningAction<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> implements IRunningActionUserMethods<DOM, ID> {
+  protected _state: IRunningActionState<DOM, ID>;
+  readonly context: ActionContext<DOM, ID>;
+  readonly cuid: string;
+  readonly id: ID;
+  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;
+  private _isAborted;
+  private readonly _updates;
+  private readonly _updateListeners;
+  constructor(initialState: IRunningActionState_ConstructorParams<DOM, ID>);
+  get state(): IRunningActionState<DOM, ID>;
+  abort(reason?: unknown): void;
+  addUpdateListeners(listeners: TRunningActionUpdateListener<DOM, ID>[]): () => void;
+  iterateUpdates(): AsyncIterable<TRunningActionUpdate<DOM, ID>>;
+  _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;
+}
+//#endregion
+//#region src/ActionRuntime/Handler/ActionHandler.d.ts
+declare abstract class ActionHandler<T extends EActionHandlerType> implements IActionHandler_Base<T> {
+  abstract readonly handlerType: T;
+  readonly cuid: string;
+  abstract readonly actionRouter: ActionRouter<any>;
+  constructor();
+  getActionRouter(): ActionRouter<any>;
+  abstract handleActionRequest<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string>(action: ActionPayload_Request<DOM, ID>, config?: IHandleActionOptions): Promise<RunningAction<DOM, ID>>;
+  abstract toJsonObject(): TActionHandler_Json;
+  abstract toHandlerRouteItem(...args: any[]): IActionRouteItemHandler;
+}
+//#endregion
+//#region src/ActionRuntime/Handler/ExternalClient/Transport/TransportConnection.d.ts
+/**
+ * Live, per-handler transport runtime built from a reusable {@link Transport} definition. Holds the
+ * connection-scoped state (ordinal, initialized config, sockets / abort sets) that must not be shared
+ * across handlers. Construct these via `definition._createConnection(...)`, never directly.
+ */
+declare abstract class TransportConnection<T extends ETransportType = ETransportType, RP extends ITransportRouteActionParams = ITransportRouteActionParams, RD extends IActionTransportReadyData_Base = IActionTransportReadyData_Base, I extends IActionTransportInitialized<RP, RD> = IActionTransportInitialized<RP, RD>, DEF extends IActionTransportDef<T, I> = IActionTransportDef<T, I>> {
+  readonly def: DEF;
+  readonly transOrd: number;
+  readonly type: T;
+  readonly initialized: I;
+  /** Backref to the public definition that created this connection (used for devtools route info). */
+  definition?: Transport<T>;
+  constructor(def: DEF);
+  /**
+   * Devtools route info for an action routed through this live connection. Defaults to the stateless
+   * {@link definition}'s info; connections override to enrich it from live state (e.g. the actual
+   * resolved socket URL) when the definition couldn't resolve it on its own.
+   */
+  getRouteInfo(input: RP): ITransportRouteInfo | undefined;
+  protected abstract _finalizeTransportMethods(inputs: RD): IActionTransportReadyData_Methods;
+  protected _getCacheKey(input: RP): string | null;
+  getCacheKey(input: RP): string | null;
+  getTransport(input: RP): TTransportStatusInfo<IActionTransportReadyData_Methods>;
+  protected _processTransportStatus(input: RP): TTransportStatusInfo<IActionTransportReadyData_Methods>;
+}
+//#endregion
+//#region src/ActionRuntime/Handler/ExternalClient/Transport/Transport.types.d.ts
+declare enum ETransportType {
+  ws = "ws",
+  http = "http",
+  custom = "custom"
+}
+/**
+ * Serializable, display-only description of how an action was routed through a transport. Stored on
+ * the action's route items and shown in the devtools external-handler chips. Keep this free of
+ * sensitive data (e.g. auth headers) — route items travel over the wire.
+ */
+interface ITransportRouteInfo {
+  type: ETransportType;
+  /** Short label for chips, e.g. "POST /resolve_action" or "ws host/resolve_action/ws". */
+  summary?: string;
+  url?: string;
+  method?: string;
+  detail?: Record<string, string | number | boolean>;
+}
+interface IUpdateActionRunConfig_Output {
+  timeout?: number;
+}
+type TUpdateActionRunConfig = (input: ITransportRouteActionParams & {
+  timeout: number;
+}) => IUpdateActionRunConfig_Output;
+interface IActionTransportReadyData_Base {
+  updateRunConfig?: TUpdateActionRunConfig;
+}
+/**
+ *
+ *  TRANSPORT READINESS RESPONSE
+ *
+ */
+declare enum ETransportStatus {
+  uninitialized = "uninitialized",
+  unsupported = "unsupported",
+  initializing = "initializing",
+  ready = "ready",
+  failed = "failed"
+}
+interface ITransportStatusInfo_Base<S extends ETransportStatus> {
+  status: S;
+}
+interface ITransportStatusInfo_Failed extends ITransportStatusInfo_Base<ETransportStatus.failed> {
+  error: NiceError;
+  timeFailed: number;
+}
+interface ITransportStatusInfo_Unsupported extends ITransportStatusInfo_Base<ETransportStatus.unsupported> {}
+interface ITransportStatusInfo_Ready<READY extends IActionTransportReadyData_Base> extends ITransportStatusInfo_Base<ETransportStatus.ready> {
+  readyData: READY;
+}
+type TTransportInitializationFinishedInfo<READY extends IActionTransportReadyData_Base> = ITransportStatusInfo_Ready<READY> | ITransportStatusInfo_Failed | ITransportStatusInfo_Unsupported;
+interface ITransportStatusInfo_Initializing<READY extends IActionTransportReadyData_Base> extends ITransportStatusInfo_Base<ETransportStatus.initializing> {
+  timeStarted: number;
+  initializationPromise: Promise<TTransportInitializationFinishedInfo<READY>>;
+}
+type TTransportStatusInfo<READY extends IActionTransportReadyData_Base> = ITransportStatusInfo_Base<ETransportStatus.uninitialized> | ITransportStatusInfo_Unsupported | ITransportStatusInfo_Initializing<READY> | ITransportStatusInfo_Ready<READY> | ITransportStatusInfo_Failed;
+type TTransportStatusInfo_GetTransport_Output<READY extends IActionTransportReadyData_Base> = ITransportStatusInfo_Base<ETransportStatus.uninitialized> | ITransportStatusInfo_Unsupported | Omit<ITransportStatusInfo_Initializing<READY>, "timeStarted"> | ITransportStatusInfo_Ready<READY> | Omit<ITransportStatusInfo_Failed, "timeFailed">;
+/**
+ *
+ *  TRANSPORT ROUTING
+ *
+ */
+interface ITransportRouteClientParams {
+  localClient: RuntimeCoordinate;
+  externalClient: RuntimeCoordinate;
+}
+interface ITransportRouteActionParams extends ITransportRouteClientParams {
+  action: TActionPayload_Any_Instance<any, any>;
+}
+interface ITransportMethod_SendActionData_Input extends ITransportRouteActionParams {
+  runningAction: RunningAction<any, any>;
+  timeout: number;
+}
+interface ITransportDispatchAction<P> extends ITransportMethod_SendActionData_Input {
+  params: P;
+}
+type TSendActionDataMethod = (input: ITransportMethod_SendActionData_Input) => void;
+type TSendReturnDataMethod = (payload: TActionPayload_Any_Instance<any, any>,
+/**
+ * The local/external client pair this payload is being returned over. Bidirectional transports use
+ * it to build the full route params their outgoing formatter expects (e.g. binary packing). Optional
+ * so existing return-data implementations keep type-checking.
+ */
+
+clients?: ITransportRouteClientParams) => void;
+interface IActionTransportReadyData_Methods extends IActionTransportReadyData_Base {
+  sendActionData: TSendActionDataMethod;
+  /**
+   * Optional — implement on bidirectional transports (WebSocket, Custom) to enable return-path
+   * routing. When present, the runtime uses this to dispatch results and progress payloads directly
+   * back to `originClient` without going through the original request transport.
+   */
+  sendReturnData?: TSendReturnDataMethod;
+  addOnDisconnectListener?: (callback: () => void) => void;
+  /**
+   * Optional — implement on transports holding a long-lived connection (WebSocket, Custom) to close it
+   * deliberately. Called by `ActionExternalClientHandler.clearTransportCache()` so a teardown actually
+   * releases the underlying socket instead of leaving it open until GC.
+   */
+  disconnect?: () => void;
+}
+interface IActionTransportReady {
+  methods: IActionTransportReadyData_Methods;
+  transport: TransportConnection;
+}
+type TTransportCache = Map<string, IActionTransportReady | Promise<IActionTransportReady>>;
+type TOnResolveIncomingRequest = (request: ActionPayload_Request<any>) => void;
+type TOnResolveIncomingRequestJson = (request: IActionPayload_Request_JsonObject<any>) => void;
+type TOnResolveIncomingResponse = (response: ActionPayload_Result<any>) => void;
+type TOnResolveIncomingResponseJson = (response: IActionPayload_Result_JsonObject<any>) => void;
+type TOnResolveAnyIncomingActionData = (actionData: ActionPayload_Request<any> | ActionPayload_Result<any>) => void;
+type TOnResolveAnyIncomingActionData_Json = (actionData: TActionPayload_Any_JsonObject<any>) => void;
+interface IActionTransportResolvers {
+  onIncomingActionDataJson: TOnResolveAnyIncomingActionData_Json;
+}
+type TGetTransportFn<IN extends ITransportRouteActionParams, READY extends IActionTransportReadyData_Base> = (input: IN) => TTransportStatusInfo_GetTransport_Output<READY>;
+interface IActionTransportInitialized<IN extends ITransportRouteActionParams, READY extends IActionTransportReadyData_Base> {
+  getTransportCacheKey?: (input: IN) => string[];
+  getTransport: TGetTransportFn<IN, READY>;
+}
+interface IActionTransportDef<TYPE extends ETransportType, INIT extends IActionTransportInitialized<any, any>> {
+  type: TYPE;
+  initialize: () => INIT;
+}
+//#endregion
+//#region src/ActionRuntime/Handler/ExternalClient/Transport/Transport.d.ts
+/**
+ * Context handed to a {@link Transport} definition when a handler builds a live connection from it.
+ * Only bidirectional transports (WebSocket / Custom) make use of `resolvers`.
+ */
+interface ITransportConnectionContext {
+  resolvers?: IActionTransportResolvers;
+}
+/**
+ * Reusable transport definition. Devs construct these (`HttpTransport.create({ createRequest })`,
+ * `WebSocketTransport.create({ createWebSocket })`, …) and pass them to an
+ * `ActionExternalClientHandler`. A single
+ * definition can be shared across multiple handlers — each handler builds its own live
+ * {@link TransportConnection} via {@link TransportConnection._createConnection}.
+ */
+declare abstract class Transport<T extends ETransportType = ETransportType> {
+  abstract readonly type: T;
+  /** Internal: build a fresh, per-handler live connection from this definition. */
+  abstract _createConnection(ctx: ITransportConnectionContext): TransportConnection<T>;
+  /**
+   * Resolve human-readable info about how a specific action would be routed through this transport
+   * (e.g. the request URL/method, or the WebSocket endpoint). Surfaced in the action devtools.
+   */
+  abstract getRouteInfo(input: ITransportRouteActionParams): ITransportRouteInfo;
+}
+//#endregion
+//#region src/ActionRuntime/Handler/ExternalClient/ActionExternalClientHandler.types.d.ts
+interface IActionExternalClientRequestHandlerConfig {
+  defaultTimeout?: number;
+  runtimeCoordinate: RuntimeCoordinate;
+  transports: Transport[];
+}
+//#endregion
+//#region src/ActionRuntime/Handler/ExternalClient/ActionExternalClientHandler.d.ts
+declare class ActionExternalClientHandler extends ActionHandler<EActionHandlerType.external> implements IActionHandler_ExternalClient {
+  readonly externalClient: RuntimeCoordinate;
+  readonly handlerType = EActionHandlerType.external;
+  readonly cuid: string;
+  private _defaultTimeout;
+  private _transportCache;
+  private transportManager;
+  private _incomingActionDataListeners;
+  readonly actionRouter: ActionRouter<true>;
+  constructor({
+    runtimeCoordinate: externalClientSpecifier,
+    transports,
+    defaultTimeout
+  }: IActionExternalClientRequestHandlerConfig);
+  forDomain<FOR_DOM extends IActionDomain>(domain: ActionDomain<FOR_DOM>): this;
+  forAction<ACT_DOM extends IActionDomain, ID extends keyof ACT_DOM["actionSchema"] & string>(action: ActionCore<ACT_DOM, ID>): this;
+  forActionIds<ACT_DOM extends IActionDomain, IDS extends ReadonlyArray<keyof ACT_DOM["actionSchema"] & string>>(domain: ActionDomain<ACT_DOM>, ids: IDS): this;
+  _setIncomingActionDataListener(listener: (json: TActionPayload_Any_JsonObject<any, any>) => void): void;
+  handleActionRequest<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string>(action: ActionPayload_Request<DOM, ID>, config?: IHandleActionOptions): Promise<RunningAction<DOM, ID>>;
+  private _dispatchWhenTransportReady;
+  /**
+   * Dispatch a result or progress payload directly back to the external client via the best
+   * available bidirectional transport (WebSocket / Custom). Used for return-path routing when the
+   * local runtime recognises that it has a direct channel to the action's originClient.
+   *
+   * Returns `true` if the payload was sent, `false` if no suitable transport was available.
+   */
+  sendReturnPayload(payload: TActionPayload_Any_Instance<any, any>, config: {
+    targetLocalRuntime: ActionRuntime;
+  }): Promise<boolean>;
+  toJsonObject(): IActionHandler_ExternalClient_Json;
+  toHandlerRouteItem(transport: TransportConnection, input: ITransportRouteActionParams): IActionRouteItemHandler;
+  clearTransportCache(): void;
+}
+declare const createExternalClientHandler: (config: IActionExternalClientRequestHandlerConfig) => ActionExternalClientHandler;
+//#endregion
+//#region src/utils/typescript/MaybePromise.d.ts
+type MaybePromise<T> = T | Promise<T>;
+//#endregion
+//#region src/ActionRuntime/Handler/Local/ActionLocalHandler.types.d.ts
+type THandleActionExecutionFn<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> = (action: TDistributeActionPayload_Request<DOM, ID>) => MaybePromise<ActionPayload_Result<DOM, ID> | IActionPayload_Result_JsonObject<DOM, ID> | TInferOutputFromSchema<DOM["actionSchema"][ID]>["Output"] | undefined>;
+//#endregion
+//#region src/ActionRuntime/Handler/Local/ActionLocalHandler.d.ts
+declare class ActionLocalHandler extends ActionHandler<EActionHandlerType.local> implements IActionHandler_Local {
+  readonly handlerType = EActionHandlerType.local;
+  readonly actionRouter: ActionRouter<THandleActionExecutionFn<any, any>>;
+  constructor();
+  /**
+   * Register a handler for all actions in a domain.
+   * Receives the full primed action — use `matchAction()` to narrow to a specific action id.
+   * Useful for forwarding all domain actions to a remote endpoint.
+   * Lower priority than `forAction`.
+   */
+  forDomain<FOR_DOM extends IActionDomain>(domain: ActionDomain<FOR_DOM>, handler: THandleActionExecutionFn<FOR_DOM>): this;
+  /**
+   * Register a handler for a base action instance. Takes priority over domain-wide handlers.
+   * Receives the full primed action with narrowed input type.
+   * Useful for handling specific actions locally while forwarding the rest of the domain. For example, a local "ping" action that checks connectivity without needing a round trip.
+   */
+  forAction<ACT_DOM extends IActionDomain, ID extends keyof ACT_DOM["actionSchema"] & string>(action: ActionCore<ACT_DOM, ID>, handler: THandleActionExecutionFn<ACT_DOM, ID>): this;
+  /**
+   * Register a handler for multiple action IDs (first-match-wins among cases).
+   * Receives the full primed action narrowed to the union of those IDs.
+   * Use `act.coreAction.id` to branch on which action was dispatched.
+   */
+  forActionIds<ACT_DOM extends IActionDomain, IDS extends ReadonlyArray<keyof ACT_DOM["actionSchema"] & string>>(domain: ActionDomain<ACT_DOM>, ids: IDS, handler: THandleActionExecutionFn<ACT_DOM, IDS[number]>): this;
+  /**
+   * Register per-action handlers for a domain using a single map, without needing
+   * separate `forAction` calls. Unregistered action IDs are unaffected.
+   *
+   * @example
+   * ```ts
+   * handler.forDomainActionCases(userDomain, {
+   *   getUser:    (primed) => db.getUser(primed.input.userId),
+   *   deleteUser: (primed) => db.deleteUser(primed.input.userId),
+   * });
+   * ```
+   */
+  forDomainActionCases<FOR_DOM extends IActionDomain>(domain: ActionDomain<FOR_DOM>, cases: { [ID in keyof FOR_DOM["actionSchema"] & string]?: THandleActionExecutionFn<FOR_DOM, ID> }): this;
+  handleActionRequest<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string>(action: ActionPayload_Request<DOM, ID>, config?: IHandleActionOptions): Promise<RunningAction<DOM, ID>>;
+  private _handleRunningAction;
+  handlePayloadWireOrThrow(wire: unknown, config?: IHandleActionOptions): Promise<RunningAction<any, any>>;
+  toJsonObject(): IActionHandler_Local_Json;
+  toHandlerRouteItem(): IActionRouteItemHandler;
+}
+declare const createLocalHandler: () => ActionLocalHandler;
+//#endregion
+//#region src/ActionRuntime/ActionRuntime.types.d.ts
+interface IRuntimeMeta {
+  assumed: boolean;
+  runtimeName: RuntimeName;
+}
+interface IActionRuntimeManagerContext {
+  domain?: string;
+}
+type TActionRuntimeHandler = ActionLocalHandler | ActionExternalClientHandler;
+//#endregion
+//#region src/ActionRuntime/ActionRuntime.d.ts
+declare class ActionRuntime {
+  private _coordinate;
+  readonly timeCreated: number;
+  readonly runtimeInfo: IRuntimeMeta;
+  private readonly actionRouter;
+  private readonly _pendingRunningActions;
+  private readonly _registeredExternalHandlers;
+  private _applied;
+  static getDefault(): ActionRuntime;
+  constructor(coordinate: RuntimeCoordinate);
+  get coordinate(): RuntimeCoordinate;
+  specifyRuntimeCoordinate(specifics: IRuntimeCoordinateSpecifics & {
+    envId?: string;
+  }): void;
+  registerRunningAction(ra: RunningAction<any, any>): void;
+  resolveIncomingActionPayload(json: TActionPayload_Any_JsonObject<any, any>): void;
+  /**
+   * Handle an incoming action wire (e.g. from a transport layer), route it to
+   * the correct handler, and return the response. The most specific handler
+   * match is chosen (action-ID-specific beats domain-wildcard).
+   */
+  handleActionPayloadWire<D extends IActionDomain, ID extends keyof D["actionSchema"] & string>(wire: TActionPayload_Any_JsonObject<D, ID>): Promise<RunningAction<D, ID>>;
+  handleActionPayloadWire(wire: unknown): Promise<RunningAction<any, any>>;
+  handleActionPayload<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string>(action: TActionPayload_Any_Instance<DOM, ID>, options?: Omit<IHandleActionOptions, "targetLocalRuntime">): Promise<RunningAction<DOM, ID>>;
+  /**
+   * @internal
+   *
+   * Return the first handler registered for the given action, or `undefined`
+   * if none has been registered (action-ID-specific beats domain-wildcard).
+   */
+  _getHandlerForAction<ACT extends TActionPayload_Any_Instance<any, any>>(action: ACT, options?: Omit<IHandleActionOptions, "targetLocalRuntime">): TActionHandler | undefined;
+  getHandlerForActionOrThrow<ACT extends TActionPayload_Any_Instance<any, any>>(action: ACT, options?: Omit<IHandleActionOptions, "localRuntime">): TActionHandler;
+  /**
+   * Register one or more handlers. Each handler's own `actionRouter` defines
+   * which domains/actions it handles — those routing keys are mirrored into
+   * this runtime's router so the same action can be served by multiple handlers.
+   * Duplicate registrations (same handler cuid for the same key) are skipped.
+   */
+  addHandlers(handlers: TActionRuntimeHandler[]): this;
+  /**
+   * Declare an external "backend client" in one call: build an
+   * {@link ActionExternalClientHandler} for `externalCoordinate` carrying the given
+   * `transports`, route the listed `domains`/`actions` to it, register it (plus any
+   * `localHandlers` — e.g. server→client push handlers that share the same channel)
+   * on this runtime, and `apply()`. Returns the external handler so the caller can
+   * later `clearTransportCache()` it.
+   *
+   * Sugar over `new ActionExternalClientHandler(...).forDomain(...)` + `addHandlers([...])`,
+   * so a single runtime can host one handler per backend target with its transports
+   * declared once and reused across every action routed to that backend.
+   */
+  connectTo(externalCoordinate: RuntimeCoordinate, options: {
+    transports: Transport[];
+    domains?: ActionDomain<any>[];
+    actions?: ActionCore<any, any>[];
+    localHandlers?: TActionRuntimeHandler[];
+    defaultTimeout?: number;
+  }): ActionExternalClientHandler;
+  private applyRuntimeForDomain;
+  /**
+   * Register this runtime with all root domains covered by its currently-added handlers,
+   * making it eligible to execute actions dispatched from those domains.
+   * After apply() is called, any subsequent addHandlers() calls also auto-register.
+   */
+  apply(): this;
+  /**
+   * Find the best registered external handler that can reach `originClient` directly.
+   * Used to locate the return-path channel for dispatching results back to the action origin.
+   * Returns `undefined` if no handler matches (score > 0 required, i.e. at least id must match).
+   */
+  getReturnHandlerForOrigin(originClient: RuntimeCoordinate): ActionExternalClientHandler | undefined;
+  resetRuntime(): void;
+  private _trySetupReturnDispatch;
+}
+//#endregion
+//#region src/ActionDefinition/Domain/ActionDomainBase.d.ts
+declare abstract class ActionDomainBase<ACT_DOM extends IActionDomain = IActionDomain> implements IActionDomain<ACT_DOM["allDomains"], ACT_DOM["actionSchema"]> {
+  readonly domain: ACT_DOM["domain"];
+  readonly allDomains: ACT_DOM["allDomains"];
+  readonly actionSchema: ACT_DOM["actionSchema"];
+  protected _listeners: TRunningActionUpdateListener<any, any>[];
+  constructor(definition: ACT_DOM);
+  /**
+   * Add an observer that is called after every action dispatched through this domain.
+   * Returns an unsubscribe function — call it to remove the listener.
+   */
+  addActionListener(listener: TDistributeRunningActionUpdateListener<ACT_DOM, keyof ACT_DOM["actionSchema"] & string>): () => void;
+  /**
+   * @internal
+   * Observers registered directly on this domain via {@link addActionListener}.
+   * Used to wire observers (e.g. devtools) onto RunningActions that aren't created
+   * through the local-dispatch path — notably inbound actions pushed from a backend
+   * or another client over a bidirectional transport.
+   */
+  _getActionObservers(): TRunningActionUpdateListener<any, any>[];
+}
+//#endregion
+//#region src/ActionDefinition/Domain/ActionRootDomain.d.ts
+declare class ActionRootDomain<ROOT_DOM extends IActionRootDomain = IActionRootDomain> extends ActionDomainBase<ROOT_DOM> {
+  readonly domainDefinition: {
+    domain: ROOT_DOM["domain"];
+  };
+  private _actionRuntimeManager;
+  constructor(domainDefinition: {
+    domain: ROOT_DOM["domain"];
+  });
+  createChildDomain<SUB_DOM extends IActionDomainChildOptions>(subDomainDef: SUB_DOM & { [K in Exclude<keyof SUB_DOM, keyof IActionDomainChildOptions>]: never }): ActionDomain<TActionDomainChildDef<ROOT_DOM, SUB_DOM>>;
+  _registerRuntime(runtime: ActionRuntime): void;
+  _hasRuntime(runtime: ActionRuntime): boolean;
+  getRuntime(clientSpecifier: IRuntimeCoordinate): ActionRuntime | undefined;
+  _runAction<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string, ACT extends ActionPayload_Request<DOM, ID> = ActionPayload_Request<DOM, ID>>(actionPayload: ACT, options?: IExecuteActionOptions<DOM, ID>): Promise<RunningAction<DOM, ID>>;
+}
+//#endregion
+//#region src/ActionDefinition/Domain/ActionDomain.d.ts
+type TActionMap<ACT_DOM extends IActionDomain> = { [K in keyof ACT_DOM["actionSchema"] & string]: ActionCore<ACT_DOM, K> };
+declare class ActionDomain<ACT_DOM extends IActionDomain = IActionDomain> extends ActionDomainBase<ACT_DOM> {
+  private _rootDomain;
+  private readonly _actionMap;
+  constructor(definition: ACT_DOM, {
+    rootDomain
+  }: {
+    rootDomain: ActionRootDomain<any>;
+  });
+  get rootDomain(): ActionRootDomain<any>;
+  /**
+   * @internal
+   * All action observers that should see actions on this domain: the root domain's
+   * observers plus this subdomain's own. Mirrors the listener set the local-dispatch
+   * path assembles in `runAction`/`_runAction`, so inbound actions (pushed from a
+   * backend or another client) can be wired up identically and surface in devtools.
+   */
+  _collectActionObservers(): TRunningActionUpdateListener<any, any>[];
+  _registerRuntime(runtime: ActionRuntime): void;
+  createChildDomain<SUB_DOM extends IActionDomainChildOptions>(subDomainDef: SUB_DOM & { [K in Exclude<keyof SUB_DOM, keyof IActionDomainChildOptions>]: never }): ActionDomain<TActionDomainChildDef<ACT_DOM, SUB_DOM>>;
+  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>;
+  hydrateRequestPayload<ID extends keyof ACT_DOM["actionSchema"] & string, P extends IActionPayload_Request_JsonObject<ACT_DOM, ID>>(serialized: P): TDistributeActionPayload_Request<ACT_DOM, ID>;
+  hydrateResultPayload<ID extends keyof ACT_DOM["actionSchema"] & string, R extends IActionPayload_Result_JsonObject<ACT_DOM, ID>>(serialized: R): TDistributeActionPayload_Result<ACT_DOM, ID>;
+  hydrateAnyAction<ID extends keyof ACT_DOM["actionSchema"] & string, AJ extends TAction_Any_JsonObject<ACT_DOM, ID>>(actionJson: AJ): TNarrowActionJsonTypeToActionInstanceType<ACT_DOM, AJ, ID>;
+  runAction<ID extends keyof ACT_DOM["actionSchema"] & string, ACT extends ActionPayload_Request<ACT_DOM, ID>>(request: ACT, options?: IExecuteActionOptions<ACT_DOM, ID>): Promise<RunningAction<ACT_DOM, ID>>;
+  private createActionMap;
+}
+//#endregion
+//#region src/ActionDefinition/Action/Core/ActionCore.d.ts
+declare class ActionCore<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends ActionBase<EActionForm.core, DOM, ID> implements IActionCore<DOM, ID> {
+  readonly _domain: ActionDomain<DOM>;
+  readonly form = EActionForm.core;
+  constructor(_domain: ActionDomain<DOM>, id: ID);
+  is<ACT extends IActionBase<any, any, any>>(action: ACT | unknown | null | undefined): action is TNarrowActionType<DOM, ACT, ID>;
+  toJsonObject(): IActionBase_JsonObject<EActionForm.core, DOM, ID>;
+  request(...args: [TInferInputFromSchema<DOM["actionSchema"][ID]>["Input"]] extends [never] ? [input?: never] : [input: TInferInputFromSchema<DOM["actionSchema"][ID]>["Input"]]): ActionPayload_Request<DOM, ID>;
+  deserializeInput(serialized: TInferInputFromSchema<DOM["actionSchema"][ID]>["SerdeInput"]): TInferInputFromSchema<DOM["actionSchema"][ID]>["Input"];
+  serializeInput(raw: TInferInputFromSchema<DOM["actionSchema"][ID]>["Input"]): TInferInputFromSchema<DOM["actionSchema"][ID]>["SerdeInput"];
+  validateInput(input: unknown): TInferInputFromSchema<DOM["actionSchema"][ID]>["Input"];
+  validateOutput(output: unknown): TInferOutputFromSchema<DOM["actionSchema"][ID]>["Output"];
+}
+//#endregion
+//#region src/ActionDefinition/Domain/helpers/createRootActionDomain.d.ts
+declare const createActionRootDomain: <ID extends string>(definition: {
+  domain: ID;
+}) => ActionRootDomain<IActionRootDomain<ID>>;
+//#endregion
+//#region src/ActionRuntime/Handler/ExternalClient/err_nice_external_client.d.ts
+declare const err_nice_external_client: import("@nice-code/error").NiceErrorDomain<{
+  domain: string;
+  allDomains: [string, string, "err_nice"];
+  schema: {};
+}>;
+//#endregion
+//#region src/ActionRuntime/Handler/ExternalClient/Transport/Custom/TransportCustom.types.d.ts
+interface IActionTransportReadyData_Custom extends IActionTransportReadyData_Base {
+  sendActionData: (input: ITransportMethod_SendActionData_Input) => void;
+  sendReturnData?: TSendReturnDataMethod;
+  closeTransport: (input?: ITransportRouteActionParams) => void;
+}
+interface IActionTransportInitialized_Custom extends IActionTransportInitialized<ITransportRouteActionParams, IActionTransportReadyData_Custom> {}
+interface IActionTransportDef_Custom extends IActionTransportDef<ETransportType.custom, IActionTransportInitialized_Custom> {}
+type TActionTransportDef_Custom_NoType = Omit<IActionTransportDef_Custom, "type">;
+//#endregion
+//#region src/ActionRuntime/Handler/ExternalClient/Transport/Custom/CustomConnection.d.ts
+declare class CustomConnection extends TransportConnection<ETransportType.custom, ITransportRouteActionParams, IActionTransportReadyData_Custom, IActionTransportInitialized_Custom, IActionTransportDef_Custom> {
+  constructor(def: TActionTransportDef_Custom_NoType);
+  protected _finalizeTransportMethods(inputs: IActionTransportReadyData_Custom): IActionTransportReadyData_Methods;
+}
+//#endregion
+//#region src/ActionRuntime/Handler/ExternalClient/Transport/Custom/CustomTransport.d.ts
+interface ICustomTransportSharedOptions {
+  updateRunConfig?: TUpdateActionRunConfig;
+  getTransportCacheKey?: (input: ITransportRouteActionParams) => string[];
+  /** Short label shown in the devtools chip (defaults to "custom"). */
+  label?: string;
+  /** Override the devtools route info for a specific action. */
+  getRouteInfo?: (input: ITransportRouteActionParams) => ITransportRouteInfo;
+}
+interface ICustomTransportSendOptions extends ICustomTransportSharedOptions {
+  /** Send a request/progress payload to the external client. */
+  sendActionData: (input: ITransportMethod_SendActionData_Input) => void;
+  /** Optional return-path dispatch for bidirectional channels. */
+  sendReturnData?: TSendReturnDataMethod;
+  closeTransport?: (input?: ITransportRouteActionParams) => void;
+}
+interface ICustomTransportAdvancedOptions extends ICustomTransportSharedOptions {
+  /** Full control over readiness/initialization for the custom channel. */
+  getTransport: IActionTransportInitialized_Custom["getTransport"];
+}
+type TCustomTransportOptions = (ICustomTransportSendOptions & {
+  mode: "send";
+}) | (ICustomTransportAdvancedOptions & {
+  mode: "advanced";
+});
+/**
+ * Reusable custom transport definition for channels nice-action doesn't model natively. Create one
+ * with `CustomTransport.create({ sendActionData })` for the simple case, or
+ * `CustomTransport.createAdvanced({ getTransport })` for full control over the lifecycle.
+ */
+declare class CustomTransport extends Transport<ETransportType.custom> {
+  private readonly options;
+  readonly type = ETransportType.custom;
+  constructor(options: TCustomTransportOptions);
+  static create(options: ICustomTransportSendOptions): CustomTransport;
+  static createAdvanced(options: ICustomTransportAdvancedOptions): CustomTransport;
+  _createConnection(_ctx: ITransportConnectionContext): CustomConnection;
+  getRouteInfo(input: ITransportRouteActionParams): ITransportRouteInfo;
+}
+//#endregion
+//#region src/ActionRuntime/Handler/ExternalClient/Transport/err_nice_transport.d.ts
+declare enum EErrId_NiceTransport {
+  timeout = "timeout",
+  not_found = "not_found",
+  unsupported = "unsupported",
+  initialization_failed = "initialization_failed",
+  send_failed = "send_failed",
+  invalid_action_response = "invalid_action_response"
+}
+declare const err_nice_transport: import("@nice-code/error").NiceErrorDomain<{
+  domain: string;
+  allDomains: [string, string, string, "err_nice"];
+  schema: {
+    timeout: import("@nice-code/error").INiceErrorIdMetadata<{
+      timeout: number;
+    }, import("@nice-code/error").JSONSerializableValue>;
+    not_found: import("@nice-code/error").INiceErrorIdMetadata<{
+      actionId: string;
+    }, import("@nice-code/error").JSONSerializableValue>;
+    unsupported: import("@nice-code/error").INiceErrorIdMetadata<{
+      transportTypes: ETransportType[];
+    }, import("@nice-code/error").JSONSerializableValue>;
+    initialization_failed: import("@nice-code/error").INiceErrorIdMetadata<{
+      actionId: string;
+    }, import("@nice-code/error").JSONSerializableValue>;
+    send_failed: import("@nice-code/error").INiceErrorIdMetadata<{
+      actionState: string;
+      actionId: string;
+      httpStatusCode?: number;
+      message?: string;
+    }, import("@nice-code/error").JSONSerializableValue>;
+    invalid_action_response: import("@nice-code/error").INiceErrorIdMetadata<{
+      actionId: string;
+    }, import("@nice-code/error").JSONSerializableValue>;
+  };
+}>;
+//#endregion
+//#region src/ActionRuntime/Handler/ExternalClient/Transport/err_nice_transport_ws.d.ts
+declare enum EErrId_NiceTransport_WebSocket {
+  ws_disconnected = "ws_disconnected",
+  ws_create_failed = "ws_create_failed",
+  ws_error = "ws_error"
+}
+declare const err_nice_transport_ws: import("@nice-code/error").NiceErrorDomain<{
+  domain: string;
+  allDomains: [string, string, string, string, "err_nice"];
+  schema: {
+    ws_disconnected: import("@nice-code/error").INiceErrorIdMetadata<Record<string, never>, import("@nice-code/error").JSONSerializableValue>;
+    ws_create_failed: import("@nice-code/error").INiceErrorIdMetadata<{
+      originalError?: Error;
+    }, import("@nice-code/error").JSONSerializableValue>;
+    ws_error: import("@nice-code/error").INiceErrorIdMetadata<{
+      originalError?: Error;
+    }, import("@nice-code/error").JSONSerializableValue>;
+  };
+}>;
+//#endregion
+//#region src/ActionRuntime/Handler/ExternalClient/Transport/Http/TransportHttp.types.d.ts
+interface IHttpRequestParams {
+  url: string;
+  headers?: Record<string, string>;
+  body?: string;
+}
+interface IActionTransportReadyParams_Http {
+  request: IHttpRequestParams;
+}
+interface IActionTransportReadyData_Http extends IActionTransportReadyData_Base {
+  createRequest: (input: ITransportRouteActionParams) => IHttpRequestParams;
+}
+interface IActionTransportInitialized_Http extends IActionTransportInitialized<ITransportRouteActionParams, IActionTransportReadyData_Http> {}
+interface IActionTransportDef_Http extends IActionTransportDef<ETransportType.http, IActionTransportInitialized_Http> {}
+//#endregion
+//#region src/ActionRuntime/Handler/ExternalClient/Transport/Http/HttpConnection.d.ts
+declare class HttpConnection extends TransportConnection<ETransportType.http, ITransportRouteActionParams, IActionTransportReadyData_Http, IActionTransportInitialized_Http, IActionTransportDef_Http> {
+  constructor(def: Omit<IActionTransportDef_Http, "type">);
+  _finalizeTransportMethods(methods: IActionTransportReadyData_Http): IActionTransportReadyData_Methods;
+  protected send(input: ITransportDispatchAction<IActionTransportReadyParams_Http>): Promise<void>;
+}
+//#endregion
+//#region src/ActionRuntime/Handler/ExternalClient/Transport/Http/HttpTransport.d.ts
+interface IHttpTransportOptions {
+  /**
+   * Build the HTTP request for an action. Return a static request for the simple case, or derive the
+   * url / headers / body from the action params for full control.
+   */
+  createRequest: (input: ITransportRouteActionParams) => IHttpRequestParams;
+  updateRunConfig?: TUpdateActionRunConfig;
+  getTransportCacheKey?: (input: ITransportRouteActionParams) => string[];
+}
+/**
+ * Reusable HTTP transport definition. Create one with `HttpTransport.create({ createRequest })` — the
+ * single `createRequest` function lets you keep it simple (`() => ({ url })`) or derive the request
+ * per action.
+ */
+declare class HttpTransport extends Transport<ETransportType.http> {
+  private readonly options;
+  readonly type = ETransportType.http;
+  constructor(options: IHttpTransportOptions);
+  static create(options: IHttpTransportOptions): HttpTransport;
+  _createConnection(_ctx: ITransportConnectionContext): HttpConnection;
+  getRouteInfo(input: ITransportRouteActionParams): ITransportRouteInfo;
+}
+//#endregion
+//#region src/ActionRuntime/Handler/ExternalClient/Transport/WebSocket/actionFrameCrypto.d.ts
+/**
+ * Async AES-GCM transform for the `encrypted` security level. It wraps the opaque binary frame a
+ * session codec produces (it does NOT look inside it), encrypting on the way out and decrypting on the
+ * way in with the shared key established by the handshake.
+ *
+ * It is deliberately separate from the (synchronous) session `formatMessage`: WebCrypto is always
+ * Promise-based, so encryption has to happen at the transport's async I/O boundary — the connection
+ * encrypts after `session.outgoing()` and decrypts before `session.incoming()`. The `authenticated`
+ * and `none` levels use no crypto transform at all (frames go out as the session produced them).
+ *
+ * Wire shape of an encrypted frame: `pack([nonceBytes, ciphertextBytes])` — msgpack carries the two
+ * binary fields with a couple of bytes of overhead, no base64 inflation.
+ */
+interface IActionFrameCrypto {
+  /** Encrypt one session frame for sending. */
+  encryptFrame(frame: Uint8Array): Promise<Uint8Array>;
+  /** Decrypt one received frame back to the session frame. Throws on a non-binary / malformed /
+   * tampered frame — the caller (transport) decides how to react (drop / close). */
+  decryptFrame(frame: string | ArrayBuffer | Uint8Array): Promise<Uint8Array>;
+}
+interface IActionFrameCryptoConfig {
+  link: ClientCryptoKeyLink;
+  /** The handshake-established link id for the remote (key + connection-registry id). */
+  linkedClientId: TTypeAndId;
+}
+/**
+ * Build the encrypt/decrypt transform for a connection whose handshake settled on the `encrypted`
+ * level. Keyed by the link + `linkedClientId`, so it reuses the cached shared AES-GCM key.
+ */
+declare function createActionFrameCrypto({
+  link,
+  linkedClientId
+}: IActionFrameCryptoConfig): IActionFrameCrypto;
+//#endregion
+//#region src/ActionRuntime/Handler/ExternalClient/Transport/WebSocket/actionWsHandshake.d.ts
+/** How much the channel protects after the handshake — chosen by the consumer (perf vs security). */
+declare enum ESecurityLevel {
+  /** No handshake; identity is self-asserted (fastest, dev / trusted networks). */
+  none = "none",
+  /** Handshake authenticates identity (sign/verify + key pin); frames stay plaintext over TLS. */
+  authenticated = "authenticated",
+  /** Authenticated handshake + every frame AES-GCM encrypted with the derived shared key. */
+  encrypted = "encrypted"
+}
+declare enum EHandshakeMessageType {
+  hello = "hello",
+  welcome = "welcome",
+  prove = "prove",
+  accept = "accept",
+  reject = "reject"
+}
+declare const vHsHello: v.ObjectSchema<{
+  readonly t: v.LiteralSchema<EHandshakeMessageType.hello, undefined>;
+  readonly protocol: v.StringSchema<undefined>;
+  readonly securityLevel: v.PicklistSchema<[ESecurityLevel.none, ESecurityLevel.authenticated, ESecurityLevel.encrypted], undefined>;
+  readonly dictionaryVersion: v.StringSchema<undefined>;
+  readonly client: v.ObjectSchema<{
+    readonly envId: v.StringSchema<undefined>;
+    readonly perId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly insId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  }, undefined>;
+  readonly clientNonce: v.StringSchema<undefined>;
+  readonly verifyPublicKey: v.CustomSchema<`ed25519::raw_base64::${string}`, undefined>;
+  readonly exchangePublicKey: v.OptionalSchema<v.CustomSchema<`x25519::raw_base64::${string}`, undefined>, undefined>;
+}, undefined>;
+declare const vHsWelcome: v.ObjectSchema<{
+  readonly t: v.LiteralSchema<EHandshakeMessageType.welcome, undefined>;
+  readonly securityLevel: v.PicklistSchema<[ESecurityLevel.none, ESecurityLevel.authenticated, ESecurityLevel.encrypted], undefined>;
+  readonly dictionaryVersion: v.StringSchema<undefined>;
+  readonly server: v.ObjectSchema<{
+    readonly envId: v.StringSchema<undefined>;
+    readonly perId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly insId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  }, undefined>;
+  readonly serverNonce: v.StringSchema<undefined>;
+  readonly verifyPublicKey: v.CustomSchema<`ed25519::raw_base64::${string}`, undefined>;
+  readonly exchangePublicKey: v.OptionalSchema<v.CustomSchema<`x25519::raw_base64::${string}`, undefined>, undefined>;
+}, undefined>;
+declare const vHsProve: v.ObjectSchema<{
+  readonly t: v.LiteralSchema<EHandshakeMessageType.prove, undefined>;
+  readonly signatureBase64: v.StringSchema<undefined>;
+}, undefined>;
+declare const vHsAccept: v.ObjectSchema<{
+  readonly t: v.LiteralSchema<EHandshakeMessageType.accept, undefined>;
+  readonly signatureBase64: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+declare const vHsReject: v.ObjectSchema<{
+  readonly t: v.LiteralSchema<EHandshakeMessageType.reject, undefined>;
+  readonly reason: v.StringSchema<undefined>;
+}, undefined>;
+declare const vHandshakeMessage: v.VariantSchema<"t", [v.ObjectSchema<{
+  readonly t: v.LiteralSchema<EHandshakeMessageType.hello, undefined>;
+  readonly protocol: v.StringSchema<undefined>;
+  readonly securityLevel: v.PicklistSchema<[ESecurityLevel.none, ESecurityLevel.authenticated, ESecurityLevel.encrypted], undefined>;
+  readonly dictionaryVersion: v.StringSchema<undefined>;
+  readonly client: v.ObjectSchema<{
+    readonly envId: v.StringSchema<undefined>;
+    readonly perId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly insId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  }, undefined>;
+  readonly clientNonce: v.StringSchema<undefined>;
+  readonly verifyPublicKey: v.CustomSchema<`ed25519::raw_base64::${string}`, undefined>;
+  readonly exchangePublicKey: v.OptionalSchema<v.CustomSchema<`x25519::raw_base64::${string}`, undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+  readonly t: v.LiteralSchema<EHandshakeMessageType.welcome, undefined>;
+  readonly securityLevel: v.PicklistSchema<[ESecurityLevel.none, ESecurityLevel.authenticated, ESecurityLevel.encrypted], undefined>;
+  readonly dictionaryVersion: v.StringSchema<undefined>;
+  readonly server: v.ObjectSchema<{
+    readonly envId: v.StringSchema<undefined>;
+    readonly perId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly insId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  }, undefined>;
+  readonly serverNonce: v.StringSchema<undefined>;
+  readonly verifyPublicKey: v.CustomSchema<`ed25519::raw_base64::${string}`, undefined>;
+  readonly exchangePublicKey: v.OptionalSchema<v.CustomSchema<`x25519::raw_base64::${string}`, undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+  readonly t: v.LiteralSchema<EHandshakeMessageType.prove, undefined>;
+  readonly signatureBase64: v.StringSchema<undefined>;
+}, undefined>, v.ObjectSchema<{
+  readonly t: v.LiteralSchema<EHandshakeMessageType.accept, undefined>;
+  readonly signatureBase64: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+  readonly t: v.LiteralSchema<EHandshakeMessageType.reject, undefined>;
+  readonly reason: v.StringSchema<undefined>;
+}, undefined>], undefined>;
+type THsHello = v.InferOutput<typeof vHsHello>;
+type THsWelcome = v.InferOutput<typeof vHsWelcome>;
+type THsProve = v.InferOutput<typeof vHsProve>;
+type THsAccept = v.InferOutput<typeof vHsAccept>;
+type THsReject = v.InferOutput<typeof vHsReject>;
+type THandshakeMessage = v.InferOutput<typeof vHandshakeMessage>;
+/** Serialize a handshake message for the wire (handshake frames are JSON — they aren't the hot path). */
+declare function encodeHandshakeMessage(message: THandshakeMessage): string;
+/** Parse + structurally validate an incoming handshake frame; `undefined` if it isn't one. */
+declare function decodeHandshakeMessage(raw: string): THandshakeMessage | undefined;
+/** Stable link id for a runtime coordinate — the key both the crypto link and the connection use. */
+declare function runtimeLinkId(coordinate: IRuntimeCoordinate): TTypeAndId;
+/**
+ * Everything needed to re-derive the shared AES-GCM key for an `encrypted` link after a restart —
+ * the remote's public keys + the HKDF salt/info used at handshake time. The local (server) key pair is
+ * recovered from its own persisted `ClientCryptoKeyLink` storage, so re-linking with this material
+ * yields the identical shared key without a fresh handshake.
+ */
+interface IHandshakeEncryptionKeyMaterial {
+  verifyPublicKey: TSerializedCryptoKeyData_Ed25519_Raw;
+  exchangePublicKey: TSerializedCryptoKeyData_X25519_Raw;
+  saltString: string;
+  infoString: string;
+  bindVerifyKeysIntoDerivation: boolean;
+}
+/** Outcome of a completed handshake — what the transport/handler needs to wire the channel. */
+interface IHandshakeResult {
+  /** The crypto-link id (and connection-registry key) for the authenticated remote. */
+  linkedClientId: TTypeAndId;
+  /** The remote's authenticated coordinate. */
+  remote: IRuntimeCoordinate;
+  securityLevel: ESecurityLevel;
+  /** For the `encrypted` level: material to restore the shared key after eviction (persist it). */
+  encryptionKeyMaterial?: IHandshakeEncryptionKeyMaterial;
+}
+interface IClientVerifyKeyResolveInput {
+  client: IRuntimeCoordinate;
+  verifyPublicKey: TSerializedCryptoKeyData_Ed25519_Raw;
+}
+interface IClientVerifyKeyResolver {
+  /**
+   * Decide whether a presented verify key is trusted for a client identity. The signature is already
+   * verified by the time this runs, so this is purely the identity-pinning decision. Swap in a
+   * persistent / pre-provisioned implementation without touching the protocol.
+   */
+  resolve(input: IClientVerifyKeyResolveInput): Promise<{
+    trusted: boolean;
+    reason?: string;
+  }>;
+}
+/**
+ * In-memory trust-on-first-use resolver: trusts (and pins) the first verify key seen for a client
+ * identity, then rejects a different key for that identity. The default; replace with a storage-backed
+ * resolver for cross-restart pinning (see Step 5).
+ */
+declare function createInMemoryTofuVerifyKeyResolver(): IClientVerifyKeyResolver;
+/**
+ * Storage-backed trust-on-first-use resolver: pins survive process restarts / Durable Object eviction
+ * (e.g. back it with `createDurableObjectStorageAdapter`). Same policy as the in-memory variant — trust
+ * + pin the first verify key per client identity, reject a different one thereafter.
+ */
+declare function createStorageTofuVerifyKeyResolver(storageAdapter: StorageAdapter): IClientVerifyKeyResolver;
+interface IClientHandshakeConfig {
+  link: ClientCryptoKeyLink;
+  localCoordinate: IRuntimeCoordinate;
+  dictionaryVersion: string;
+  securityLevel: ESecurityLevel;
+}
+declare function createClientHandshake(config: IClientHandshakeConfig): {
+  createHello(): Promise<THsHello>;
+  onWelcome(welcome: THsWelcome): Promise<THsProve>;
+  onAccept(accept: THsAccept): Promise<IHandshakeResult>;
+};
+interface IServerHandshakeConfig {
+  link: ClientCryptoKeyLink;
+  localCoordinate: IRuntimeCoordinate;
+  dictionaryVersion: string;
+  /**
+   * The level(s) this server accepts. A single level is strict (the client must match). An array is a
+   * negotiable allowed set — the server adopts whichever level the client requests, as long as it's in
+   * the set (lets one backend serve `authenticated` and `encrypted` clients at once). `none` in the set
+   * is handled by the transport/handler (a `none` client never reaches the handshake).
+   */
+  securityLevel: ESecurityLevel | readonly ESecurityLevel[];
+  /** Trust decision for a client's verify key. Defaults to in-memory TOFU. */
+  verifyKeyResolver?: IClientVerifyKeyResolver;
+}
+declare function createServerHandshake(config: IServerHandshakeConfig): {
+  onHello(hello: THsHello): Promise<THsWelcome | THsReject>;
+  onProve(prove: THsProve): Promise<THsAccept | THsReject>; /** The completed handshake result once `onProve` has accepted, else `undefined`. */
+  getResult(): IHandshakeResult | undefined;
+};
+//#endregion
+//#region src/ActionRuntime/Handler/ExternalClient/Transport/WebSocket/TransportWebSocket.types.d.ts
+/**
+ * Client-side secure-channel config for a WebSocket. When present (and `securityLevel !== none`), the
+ * connection runs the {@link createClientHandshake} handshake during initialization — authenticating
+ * the identity and, for the `encrypted` level, deriving a shared key that encrypts every action frame.
+ */
+interface IWsClientSecureChannel {
+  securityLevel: ESecurityLevel;
+  /** This client's crypto identity (verify + exchange key pairs, optionally persisted). */
+  link: ClientCryptoKeyLink;
+  /** This client's runtime coordinate — its authenticated identity to the server. */
+  localCoordinate: IRuntimeCoordinate;
+  /** Wire dictionary version; the server rejects the handshake on a mismatch. */
+  dictionaryVersion: string;
+}
+interface IActionTransportReadyData_Ws extends IActionTransportReadyData_Base {
+  formatMessage?: {
+    /**
+     * Pack an outgoing action payload. Return a `string` for text frames (JSON) or a binary
+     * `Uint8Array`/`ArrayBuffer` for optimized binary frames (e.g. msgpackr).
+     */
+    outgoing: (input: ITransportRouteActionParams) => string | Uint8Array | ArrayBuffer;
+    /**
+     * Unpack an incoming frame back into the wire JSON object the runtime hydrates + validates.
+     * Return `undefined` to defer to the connection's built-in JSON parser — this is how binary
+     * adapters stay backward compatible with plain-JSON clients on the same socket.
+     */
+    incoming?: (input: string | ArrayBuffer | Uint8Array | Blob) => TActionPayload_Any_JsonObject<any, any> | undefined;
+  };
+  ws: WebSocket;
+  /** Optional authenticated/encrypted channel; the connection runs the handshake during init. */
+  secureChannel?: IWsClientSecureChannel;
+}
+interface IActionTransportInitialized_Ws extends IActionTransportInitialized<ITransportRouteActionParams, IActionTransportReadyData_Ws> {}
+interface IActionTransportDef_Ws extends IActionTransportDef<ETransportType.ws, IActionTransportInitialized_Ws> {}
+//#endregion
+//#region src/ActionRuntime/Handler/ExternalClient/Transport/WebSocket/createBinaryWsAdapter.d.ts
+/**
+ * Builds a *stateless* `formatMessage` pipeline for {@link WebSocketTransport}, packing action
+ * payloads into a compact msgpackr binary frame instead of JSON. The `domain`/`id` route collapses to
+ * a single integer drawn from a shared dictionary; `form`/`type`, the recomputable
+ * `inputHash`/`outputHash`, and the per-frame `context.routing`/`context.timeCreated` are all dropped
+ * (see {@link ENVELOPE}).
+ *
+ * No validation runs here: `incoming` blindly reconstructs the wire JSON shape and hands it back to
+ * the connection, which flows into `ActionRuntime` → `domain.hydrateAnyAction()` where the Valibot
+ * schemas validate it exactly as they would for a JSON frame.
+ *
+ * Both ends of the socket MUST construct the adapter with the same domains in the same order — the
+ * integer dictionary is positional. Mismatched dictionaries will route to the wrong action.
+ *
+ * Because `incoming` returns `undefined` for text frames, a binary server can still serve plain-JSON
+ * clients on the same runtime (the connection falls back to its built-in JSON parser).
+ */
+declare function createBinaryWsAdapter(domains: ActionDomain<any>[]): NonNullable<IActionTransportReadyData_Ws["formatMessage"]>;
+//#endregion
+//#region src/ActionRuntime/Handler/ExternalClient/Transport/WebSocket/createBinaryWsSessionFactory.d.ts
+type TFormatMessage = NonNullable<IActionTransportReadyData_Ws["formatMessage"]>;
+interface IBinaryWsSessionOptions {
+  /** Override how long an unresolved correlation is retained before being swept (ms). */
+  correlationTtlMs?: number;
+}
+/**
+ * Builds a factory of *stateful, per-connection* codecs for {@link WebSocketTransport} /
+ * `ActionServerHandler` — the maximally compact binary wire. Call the returned factory once per live
+ * connection (each socket on the client, each accepted connection on the server) so every channel
+ * gets its own correlation + identity state.
+ *
+ * On top of everything {@link createBinaryWsAdapter} drops, a session also drops:
+ * - **`cuid`** — replaced by a per-connection integer correlation id. The initiator maps it to its
+ *   real cuid; the responder echoes it; each side reconstructs the cuid from its own map. Correlation
+ *   only needs to be unique per socket, so a counter suffices.
+ * - **`originClient` after the first request** — the first request each side sends carries its
+ *   identity; the peer remembers it and injects it into later frames. Replies omit it entirely (a
+ *   reply carries the initiator's own origin, which the initiator already knows).
+ *
+ * Both ends MUST build the factory from the same domains in the same order (positional dictionary).
+ * Text frames still return `undefined` from `incoming`, so JSON clients remain interoperable.
+ *
+ * Hibernation note: after a server connection is evicted its session resets, so a still-connected
+ * client (whose session persists) will keep omitting `originClient`. The server must therefore restore
+ * the connection→client binding from its own store (see `ActionServerHandler.rehydrateConnection`) and
+ * inject `originClient` from there — the session alone can't recover it.
+ */
+declare function createBinaryWsSessionFactory(domains: ActionDomain<any>[], options?: IBinaryWsSessionOptions): () => TFormatMessage;
+//#endregion
+//#region src/ActionRuntime/Handler/ExternalClient/Transport/WebSocket/WebSocketConnection.d.ts
+declare class WebSocketConnection extends TransportConnection<ETransportType.ws, ITransportRouteActionParams, IActionTransportReadyData_Ws, IActionTransportInitialized_Ws, IActionTransportDef_Ws> {
+  private resolvers;
+  /** URL of the most recently resolved live socket — surfaced to devtools when the definition can't. */
+  private _liveSocketUrl?;
+  /** Sockets we closed on purpose (via `disconnect`), so their `close` event stays quiet. */
+  private _intentionalCloses;
+  constructor(def: Omit<IActionTransportDef_Ws, "type">, resolvers?: IActionTransportResolvers);
+  protected _getCacheKey(_input: ITransportRouteActionParams): string;
+  protected _processTransportStatus(input: ITransportRouteActionParams): TTransportStatusInfo<IActionTransportReadyData_Methods>;
+  getRouteInfo(input: ITransportRouteActionParams): ITransportRouteInfo | undefined;
+  private _isSecure;
+  private _awaitOpen;
+  /** Non-secure connections finalize synchronously; secure ones run the handshake first. */
+  private _finalize;
+  _finalizeTransportMethods(wsData: IActionTransportReadyData_Ws): IActionTransportReadyData_Methods;
+  /**
+   * Secure path: a single message listener feeds the handshake until it completes, then routes action
+   * frames (decrypting for the `encrypted` level). Frames that arrive in the gap between accept and
+   * activation are buffered and flushed, so nothing is lost.
+   */
+  private _finalizeSecureMethods;
+  private _runClientHandshake;
+  private _buildSendMethods;
+  /** Decode (and, when encrypted, decrypt) one inbound action frame and hand it to the runtime. */
+  private _handleIncomingActionFrame;
+  /** Accept text + binary frames (ArrayBuffer / Uint8Array / Blob); Blobs are converted to a buffer. */
+  private _normalizeFrame;
+  private _captureSocketUrl;
+  private _attachLifecycle;
+  private _abortAll;
+}
+//#endregion
+//#region src/ActionRuntime/Handler/ExternalClient/Transport/WebSocket/WebSocketTransport.d.ts
+interface IWebSocketTransportSharedOptions {
+  /** Custom (de)serialization of action payloads on the wire (shared across all sockets). */
+  formatMessage?: IActionTransportReadyData_Ws["formatMessage"];
+  /**
+   * Per-socket codec factory — called once for each socket so stateful codecs (e.g. the
+   * `createBinaryWsSessionFactory` session, which holds per-connection correlation + identity state)
+   * get their own instance and reset cleanly on reconnect. Takes precedence over `formatMessage`.
+   */
+  createFormatMessage?: () => IActionTransportReadyData_Ws["formatMessage"];
+  updateRunConfig?: TUpdateActionRunConfig;
+  /**
+   * Keys that identify a reusable socket, so a single socket is shared across actions to the same
+   * endpoint instead of opening one per action.
+   */
+  getTransportCacheKey?: (input: ITransportRouteActionParams) => string[];
+  /** Override the devtools route info for a specific action. */
+  getRouteInfo?: (input: ITransportRouteActionParams) => ITransportRouteInfo;
+  /**
+   * Secure-channel config. When set (and `securityLevel !== none`), the connection runs the
+   * authenticated handshake during initialization and, at the `encrypted` level, encrypts every frame.
+   */
+  security?: IActionTransportReadyData_Ws["secureChannel"];
+}
+interface IWebSocketTransportSocketOptions extends IWebSocketTransportSharedOptions {
+  /** Open (or reuse) the WebSocket for an action — keep it simple or derive it per action. */
+  createWebSocket: (input: ITransportRouteActionParams) => WebSocket;
+}
+interface IWebSocketTransportAdvancedOptions extends IWebSocketTransportSharedOptions {
+  /**
+   * Full control over readiness/initialization. Use this for contextual support detection (return
+   * `{ status: ETransportStatus.unsupported }` when the socket shouldn't be used) or async url
+   * building (return `{ status: ETransportStatus.initializing, initializationPromise }` that resolves
+   * to a `ready` socket).
+   */
+  getTransport: IActionTransportInitialized_Ws["getTransport"];
+}
+type TWebSocketTransportOptions = (IWebSocketTransportSocketOptions & {
+  mode: "socket";
+}) | (IWebSocketTransportAdvancedOptions & {
+  mode: "advanced";
+});
+/**
+ * Reusable WebSocket transport definition. Create one with `WebSocketTransport.create({ createWebSocket })`
+ * for the common case, or `WebSocketTransport.createAdvanced({ getTransport })` for full control over
+ * readiness. The underlying socket is cached (via `getTransportCacheKey`) and reused across actions.
+ */
+declare class WebSocketTransport extends Transport<ETransportType.ws> {
+  private readonly options;
+  readonly type = ETransportType.ws;
+  constructor(options: TWebSocketTransportOptions);
+  static create(options: IWebSocketTransportSocketOptions): WebSocketTransport;
+  static createAdvanced(options: IWebSocketTransportAdvancedOptions): WebSocketTransport;
+  _createConnection(ctx: ITransportConnectionContext): WebSocketConnection;
+  getRouteInfo(input: ITransportRouteActionParams): ITransportRouteInfo;
+}
+//#endregion
+//#region src/ActionRuntime/Handler/ExternalClient/Transport/WebSocket/secureWsChannel.d.ts
+/** The per-connection binary session codec — built once per socket from the channel's domains. */
+type TChannelCodec = NonNullable<IActionTransportReadyData_Ws["formatMessage"]>;
+/**
+ * The shared identity of a secure WebSocket channel: the wire dictionary version both ends check
+ * during the handshake, plus the per-connection codec factory both ends build from the *same* domain
+ * list. Define it once (typically in code shared by client and server) and hand it to
+ * {@link createSecureWebSocketTransport} on the client and `createSecureActionServerHandler` on the
+ * server, so the codec and version can never drift apart.
+ */
+interface ISecureWsChannel {
+  /** Wire dictionary version — derived from the domains by default; the handshake rejects a mismatch. */
+  dictionaryVersion: string;
+  /** Per-connection session codec factory (call once per live connection). */
+  createCodec: () => TChannelCodec;
+}
+/**
+ * Bundle a secure channel's shared identity from its transported domains. Both ends MUST call this
+ * with the same domains in the same order (the binary wire dictionary is positional). The
+ * `dictionaryVersion` is derived from those domains unless you pin an explicit one.
+ */
+declare function defineSecureWsChannel(options: {
+  /** Domains transported over this channel, in a stable order. Add new ones to the *end*. */domains: ActionDomain<any>[]; /** Pin a human-readable version instead of the derived hash (must match on both ends). */
+  dictionaryVersion?: string; /** Tuning for the per-connection binary session (e.g. correlation TTL). */
+  sessionOptions?: IBinaryWsSessionOptions;
+}): ISecureWsChannel;
+interface ISecureWebSocketTransportOptions {
+  /** The shared channel identity (codec + dictionary version). */
+  channel: ISecureWsChannel;
+  /** This client's runtime — its coordinate is the authenticated identity sent in the handshake. */
+  runtime: ActionRuntime;
+  /** Backing store for this client's crypto identity (a stable verify key across reloads). */
+  storageAdapter: StorageAdapter;
+  /** The level this client requests; the server must allow it. */
+  securityLevel: ESecurityLevel;
+  /** Endpoint URL — drives both the socket and the per-endpoint cache key. */
+  url: string;
+  /** Override socket creation (defaults to a `new WebSocket(url)` with `binaryType = "arraybuffer"`). */
+  createWebSocket?: (input: ITransportRouteActionParams) => WebSocket;
+  /** Override the reuse key (defaults to `[url]`, so one socket is shared per endpoint). */
+  getTransportCacheKey?: (input: ITransportRouteActionParams) => string[];
+  updateRunConfig?: TUpdateActionRunConfig;
+  getRouteInfo?: (input: ITransportRouteActionParams) => ITransportRouteInfo;
+}
+/**
+ * Build a {@link WebSocketTransport} for the secure binary channel with the boilerplate folded in: it
+ * creates the {@link ClientCryptoKeyLink} from `storageAdapter`, opens an `arraybuffer` socket to
+ * `url`, caches it per endpoint, installs the channel's per-connection codec, and assembles the
+ * `security` block from the runtime coordinate + channel version. Pass `createWebSocket` /
+ * `getTransportCacheKey` to take over those bits when you need to.
+ */
+declare function createSecureWebSocketTransport(options: ISecureWebSocketTransportOptions): WebSocketTransport;
+//#endregion
+//#region src/ActionRuntime/Handler/Server/WsConnectionStateStore.d.ts
+/**
+ * The composite value persisted to a connection's attachment: the consumer's own app state plus the
+ * {@link ActionServerHandler} routing binding. Co-storing them in one slot means a transport whose
+ * sockets outlive process eviction (e.g. a Durable Object's hibernatable WebSocket) recovers both the
+ * application identity *and* the action routing from a single attachment after a wake — no storage reads.
+ */
+interface IConnectionAttachment<TApp> {
+  app?: TApp;
+  binding?: IActionServerConnectionBinding;
+}
+interface IWsConnectionStateStoreOptions<TConn, TApp> {
+  /** Read a connection's raw attachment (e.g. `(ws) => ws.deserializeAttachment()`). */
+  read: (connection: TConn) => unknown;
+  /** Persist a connection's attachment (e.g. `(ws, value) => ws.serializeAttachment(value)`). */
+  write: (connection: TConn, value: IConnectionAttachment<TApp>) => void;
+  /**
+   * All currently-live connections (e.g. `() => ctx.getWebSockets()`). Used to replay routing bindings
+   * after a wake (via {@link ActionServerHandler.createConnectionState}) and to enumerate app state in
+   * {@link WsConnectionStateStore.entries}.
+   */
+  getConnections: () => TConn[];
+  /**
+   * Optional Standard Schema (valibot, zod, …) validating the *app* portion on read. A value that
+   * fails validation reads back as `null` — the same lenient behavior as a hand-written safeParse
+   * helper. The binding is the library's own shape and is never validated.
+   */
+  schema?: StandardSchemaV1<unknown, TApp>;
+}
+/**
+ * A typed per-connection state store that co-owns the app state and the server handler's routing
+ * binding in one attachment, so neither the consumer nor the handler has to hand-merge the two. Create
+ * it through {@link ActionServerHandler.createConnectionState} (which also wires binding persistence and
+ * replays surviving connections after a wake), then `get`/`set`/`clearApp` the app state directly.
+ *
+ * ```ts
+ * const players = serverHandler.createConnectionState({
+ *   schema: vs_player,
+ *   read: (ws) => ws.deserializeAttachment(),
+ *   write: (ws, v) => ws.serializeAttachment(v),
+ *   getConnections: () => ctx.getWebSockets(),
+ * });
+ * players.set(ws, player); // binding is preserved automatically
+ * const player = players.get(ws);
+ * ```
+ */
+declare class WsConnectionStateStore<TConn, TApp> {
+  private readonly options;
+  constructor(options: IWsConnectionStateStoreOptions<TConn, TApp>);
+  /** The validated app state for a connection, or `null` if unset / invalid. */
+  get(connection: TConn): TApp | null;
+  /** Set the app state, preserving the runtime binding already pinned to the connection. */
+  set(connection: TConn, app: TApp): void;
+  /** Clear the app state but keep the binding (e.g. a spectator that stopped watching). */
+  clearApp(connection: TConn): void;
+  /** Every live connection paired with its (validated) app state — for rebuilding in-memory state after a wake. */
+  entries(): [TConn, TApp | null][];
+  /** @internal Persist a freshly-bound connection's binding, preserving any app state already stored. */
+  _persistBinding(connection: TConn, binding: IActionServerConnectionBinding): void;
+  /** @internal The persisted binding for a connection, if any (used to replay routing after a wake). */
+  _readBinding(connection: TConn): IActionServerConnectionBinding | undefined;
+  private _readAttachment;
+  private _validateApp;
+}
+//#endregion
+//#region src/ActionRuntime/Handler/Server/ActionServerHandler.d.ts
+/** The codec shape `ActionServerHandler` uses to pack/unpack frames — same as the WS transport's. */
+type TActionChannelFormatMessage = NonNullable<IActionTransportReadyData_Ws["formatMessage"]>;
+/** How a connection encodes its frames, remembered so we answer each client in its own dialect. */
+type TActionConnectionEncoding = "json" | "binary";
+/** A connection's restorable identity — what to persist so a binding survives transport eviction. */
+interface IActionServerConnectionBinding {
+  /** Full client coordinate, so `originClient` can be re-injected into frames that omit it. */
+  client: IRuntimeCoordinate;
+  encoding: TActionConnectionEncoding;
+  /**
+   * Secure-session state (set once a connection's handshake completes). Persist it alongside the
+   * binding so an authenticated/encrypted connection resumes after eviction without re-handshaking —
+   * the `keyMaterial` lets the server re-derive the shared key from its own persisted identity.
+   */
+  secure?: {
+    securityLevel: ESecurityLevel;
+    linkedClientId: TTypeAndId;
+    keyMaterial?: IHandshakeEncryptionKeyMaterial;
+  };
+}
+/**
+ * Server-side secure-channel config. When set, each connection negotiates a level from
+ * {@link securityLevel}: an `authenticated`/`encrypted` client must complete the handshake (and is then
+ * bound to its *authenticated* coordinate) before any action frame is accepted. A `none` client (only
+ * when `none` is in the allowed set) is accepted as-is with a self-asserted identity. For the
+ * `encrypted` level the codec source should be a session factory (`createFormatMessage`).
+ */
+interface IActionServerSecurity {
+  /**
+   * Accepted level(s). A single level is strict; an array is a negotiable allowed set — the server
+   * adopts whichever level each client requests (e.g. `[none, authenticated, encrypted]` serves all
+   * three over one endpoint).
+   */
+  securityLevel: ESecurityLevel | readonly ESecurityLevel[];
+  /** This server's crypto identity (verify + exchange key pairs, optionally persisted). */
+  link: ClientCryptoKeyLink;
+  /** This server's coordinate — its identity to clients during the handshake. */
+  localCoordinate: IRuntimeCoordinate;
+  /** Wire dictionary version; the handshake rejects a client on a mismatch. */
+  dictionaryVersion: string;
+  /** Trust decision for a client's verify key (defaults to in-memory TOFU inside the handshake). */
+  verifyKeyResolver?: IClientVerifyKeyResolver;
+}
+interface IActionServerHandlerBaseOptions<TConn> {
+  /**
+   * Coordinate of the *connecting clients* (typically env-only, e.g. `RuntimeCoordinate.env("web_app")`).
+   * The runtime's return-path dispatch scores incoming actions' `originClient` against this to pick
+   * this handler for sending results/pushes back over the right channel.
+   */
+  clientEnv: RuntimeCoordinate;
+  /** Write an encoded frame to a specific live connection (e.g. `(ws, frame) => ws.send(frame)`). */
+  send: (connection: TConn, frame: string | Uint8Array | ArrayBuffer) => void;
+  /**
+   * The runtime this handler belongs to. When set, {@link ActionServerHandler.broadcast} can be called
+   * without threading a runtime through each call. Optional — `pushToClient` still takes one explicitly.
+   */
+  runtime?: ActionRuntime;
+  /** Timeout (ms) applied to server-initiated actions awaiting a client response. */
+  defaultTimeout?: number;
+  /**
+   * Called once when a connection is first bound to a client identity. Use it to persist the binding
+   * for transports that can resume after eviction — e.g. a Durable Object's hibernatable WebSocket:
+   * `(ws, binding) => ws.serializeAttachment(binding)` — then replay it via {@link ActionServerHandler.rehydrateConnection}
+   * when the channel comes back.
+   */
+  onConnectionBound?: (connection: TConn, binding: IActionServerConnectionBinding) => void;
+  /**
+   * Enable the authenticated (optionally encrypted) handshake. When omitted, connections are trusted
+   * as-is (identity self-asserted) — fine for dev / trusted networks.
+   */
+  security?: IActionServerSecurity;
+}
+/**
+ * Provide exactly one codec source:
+ * - `formatMessage` — a single shared codec for every connection (stateless, e.g. `createBinaryWsAdapter`).
+ * - `createFormatMessage` — a per-connection factory for stateful codecs (e.g.
+ *   `createBinaryWsSessionFactory`, whose sessions hold correlation + identity state). Required for the
+ *   leanest binary wire; the handler creates and caches one codec per connection.
+ */
+type IActionServerHandlerOptions<TConn> = IActionServerHandlerBaseOptions<TConn> & ({
+  formatMessage: TActionChannelFormatMessage;
+  createFormatMessage?: never;
+} | {
+  createFormatMessage: () => TActionChannelFormatMessage;
+  formatMessage?: never;
+});
+/**
+ * A connection-aware execution case (see {@link ActionServerHandler.forConnectionDomainCases}). It
+ * receives the primed request plus the originating client's live connection (already resolved from the
+ * request's `originClient`, `undefined` if the socket is gone), and may return the action's raw output,
+ * a result payload, or nothing (auto-wrapped as an empty success) — exactly like a local handler case.
+ */
+type TServerConnectionCaseFn<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string, TConn> = (action: TDistributeActionPayload_Request<DOM, ID>, connection: TConn | undefined) => ReturnType<THandleActionExecutionFn<DOM, ID>> | void;
+/**
+ * Server-side handler for backends that accept many client connections over a single open channel
+ * (WebSockets, Durable Objects, …). It is transport-agnostic: you feed it inbound frames with
+ * {@link receive} and tell it how to write outbound frames via the `send` option.
+ *
+ * Add it alongside your local execution handler:
+ * ```ts
+ * const serverHandler = createServerHandler({ clientEnv, formatMessage, send: (ws, f) => ws.send(f) });
+ * runtime.addHandlers([localHandler, serverHandler]);
+ * // per inbound message (e.g. a Durable Object's webSocketMessage):
+ * serverHandler.receive(ws, message);
+ * ```
+ *
+ * Inbound requests route to your local handler; the runtime's return dispatch then calls this
+ * handler back (it is an external handler keyed to `clientEnv`) to send the result to the originating
+ * connection. The handler keeps a per-connection identity registry so each result lands on the right
+ * socket, and remembers each connection's encoding so binary and JSON clients can share the channel.
+ *
+ * It registers an empty action router, so it is never chosen to *execute* an inbound request — only
+ * to ferry results/pushes back out.
+ */
+declare class ActionServerHandler<TConn = unknown> extends ActionExternalClientHandler {
+  private readonly _formatMessage?;
+  private readonly _createFormatMessage?;
+  private readonly _send;
+  private readonly _runtime?;
+  private readonly _serverTimeout;
+  private _onConnectionBound?;
+  /** Incoming-data listeners installed by the runtime (`resolveIncomingActionPayload`). */
+  private readonly _incomingListeners;
+  private readonly _security?;
+  /** Normalized accepted levels; whether `none` (plain) is allowed; whether any level needs a handshake. */
+  private readonly _allowedLevels;
+  private readonly _noneAllowed;
+  private readonly _handshakeMode;
+  private readonly _connByClient;
+  private readonly _clientByConn;
+  private readonly _connEncoding;
+  private readonly _codecByConn;
+  private readonly _handshakeByConn;
+  private readonly _cryptoByConn;
+  private readonly _authedConns;
+  private readonly _plainConns;
+  private readonly _inboundChainByConn;
+  private readonly _outboundChainByConn;
+  constructor(options: IActionServerHandlerOptions<TConn>);
+  /**
+   * The codec for a connection: a per-connection session (cached) when a factory was provided, else
+   * the single shared `formatMessage`.
+   */
+  private _codecFor;
+  _setIncomingActionDataListener(listener: (json: TActionPayload_Any_JsonObject<any>) => void): void;
+  /**
+   * Register (or replace) the connection-bound persistence callback after construction. Used by
+   * lifecycle helpers like {@link createHibernatableWsServerAdapter} so persistence and replay are
+   * owned by one place instead of being split across the constructor options.
+   */
+  setOnConnectionBound(onConnectionBound: (connection: TConn, binding: IActionServerConnectionBinding) => void): void;
+  /**
+   * Create a typed per-connection state store that co-owns the consumer's app state and this handler's
+   * routing binding in one attachment. It registers itself as the connection-bound persistence callback
+   * (so bindings are written without overwriting app state) and immediately replays every live
+   * connection's stored binding via {@link rehydrateConnection} — so on a transport that resumes after
+   * eviction (e.g. a Durable Object waking from hibernation) both the app identity and the action
+   * routing come back from a single attachment, with no storage reads and no hand-rolled merge.
+   *
+   * This supersedes {@link createHibernatableWsServerAdapter} for app code that also pins its own state
+   * to the connection. Construct it once when the handler is built, then `get`/`set` app state directly.
+   */
+  createConnectionState<TApp>(options: IWsConnectionStateStoreOptions<TConn, TApp>): WsConnectionStateStore<TConn, TApp>;
+  /**
+   * Feed one inbound frame from a connection into the runtime. Decodes text or binary, binds the
+   * connection to the requesting client's identity, then routes it (requests execute locally;
+   * results/progress resolve pending server-initiated actions).
+   */
+  receive(connection: TConn, frame: string | ArrayBuffer | Uint8Array): void;
+  private _receivePlain;
+  private _receiveSecure;
+  private _completeServerHandshake;
+  /**
+   * Ensure an inbound request carries the client's identity and that this connection is bound to it,
+   * so its result can be routed back. A session codec omits `originClient` after the first request, so
+   * when it's missing we restore it from the (possibly rehydrated) binding instead. (Plain mode only;
+   * secure mode binds the authenticated coordinate at handshake time.)
+   */
+  private _resolveRequestIdentity;
+  /**
+   * Restore a connection→client binding without an inbound frame — for transports that resume after
+   * eviction. Pair it with the {@link IActionServerHandlerOptions.onConnectionBound} hook: persist
+   * the binding there, then replay each live connection here when the channel comes back (e.g. a
+   * Durable Object iterating `ctx.getWebSockets()` as it wakes from hibernation).
+   */
+  rehydrateConnection(connection: TConn, binding: IActionServerConnectionBinding): void;
+  toHandlerRouteItem(): IActionRouteItemHandler;
+  /** Forget a connection (call on socket close) so stale entries don't misroute later results. */
+  dropConnection(connection: TConn): void;
+  /** Live connection for a client coordinate, if currently registered. */
+  getConnectionForClient(client: RuntimeCoordinate): TConn | undefined;
+  /**
+   * Send (and optionally await) a server-initiated action to a specific connected client. Pass the
+   * connection token directly (e.g. the `ws`) or a client `RuntimeCoordinate` to look one up.
+   */
+  pushToClient<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string>(runtime: ActionRuntime, target: TConn | RuntimeCoordinate, request: ActionPayload_Request<DOM, ID>, options?: {
+    timeout?: number;
+  }): RunningAction<DOM, ID>;
+  /**
+   * Build a local handler whose cases are connection-aware: each case receives the primed request and
+   * the originating client's live connection (resolved from `originClient`), so handlers don't repeat
+   * the `getConnectionForClient(action.context.originClient)` lookup. Cases may return raw output or
+   * nothing, just like {@link ActionLocalHandler.forDomainActionCases}. Add the returned handler to the
+   * runtime alongside this server handler:
+   * ```ts
+   * runtime.addHandlers([serverHandler.forConnectionDomainCases(domain, { … }), serverHandler]);
+   * ```
+   */
+  forConnectionDomainCases<FOR_DOM extends IActionDomain>(domain: ActionDomain<FOR_DOM>, cases: { [ID in keyof FOR_DOM["actionSchema"] & string]?: TServerConnectionCaseFn<FOR_DOM, ID, TConn> }): ActionLocalHandler;
+  /**
+   * Fan a server-initiated request out to every currently-bound connection. A fresh request is built
+   * per connection (each push mutates its own action context) and dispatched fire-and-forget. Pass
+   * `except` to skip the originating socket and `where` to filter by connection (e.g. read its
+   * attachment for a role). Iterating bound connections (rather than every accepted socket) skips
+   * sockets that are still mid-handshake and so can't yet receive a frame.
+   */
+  broadcast<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string>(makeRequest: () => ActionPayload_Request<DOM, ID>, options?: {
+    runtime?: ActionRuntime;
+    except?: TConn | null;
+    where?: (connection: TConn) => boolean;
+    timeout?: number;
+    onError?: (error: unknown, connection: TConn) => void;
+  }): void;
+  sendReturnPayload(payload: TActionPayload_Any_Instance<any, any>, config: {
+    targetLocalRuntime: ActionRuntime;
+  }): Promise<boolean>;
+  handleActionRequest<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string>(action: ActionPayload_Request<DOM, ID>, config?: IHandleActionOptions): Promise<RunningAction<DOM, ID>>;
+  private _dispatch;
+  private _sendPayload;
+  private _bindConnection;
+  private _resolveConnection;
+  private _resolveSingleConnection;
+}
+declare const createServerHandler: <TConn = unknown>(options: IActionServerHandlerOptions<TConn>) => ActionServerHandler<TConn>;
+//#endregion
+//#region src/ActionRuntime/Handler/Server/createActionFetchHandler.d.ts
+interface IActionFetchHandlerOptions {
+  /**
+   * CORS headers merged onto every response (a preflight `OPTIONS` is answered `204` with them).
+   * Defaults to permissive `*`; pass `false` to attach no CORS headers at all.
+   */
+  cors?: Record<string, string> | false;
+  /** Which requests carry an action wire on `POST`. Default: pathname ends with `/action`. */
+  isActionPath?: (url: URL) => boolean;
+  /** Which requests are WebSocket upgrades. Default: pathname ends with `/ws`. */
+  isWebSocketPath?: (url: URL) => boolean;
+  /**
+   * Perform the transport-specific WebSocket upgrade (e.g. a Durable Object's
+   * `new WebSocketPair()` + `ctx.acceptWebSocket()` returning a `101`). Omit for HTTP-only endpoints.
+   * Its response is returned as-is — a `101` upgrade carries no CORS headers.
+   */
+  onWebSocketUpgrade?: (request: Request, url: URL) => Response | Promise<Response>;
+  /** Forwarded to `ActionPayload_Result.toHttpResponse` — use the error's HTTP status (default true). */
+  useErrorStatus?: boolean;
+}
+/**
+ * Build the `fetch` handler a server/Durable-Object exposes for action traffic, folding in the
+ * boilerplate every endpoint repeats: CORS (incl. the `OPTIONS` preflight), routing the `/action`
+ * `POST` body through the runtime (`handleActionPayloadWire` → `waitForResultPayload` →
+ * `toHttpResponse`), an optional WebSocket-upgrade hook, and a `404` fallback.
+ *
+ * It only touches web-standard `Request`/`Response`, so it stays transport-agnostic — the one
+ * environment-specific bit (the WS upgrade) is injected via {@link IActionFetchHandlerOptions.onWebSocketUpgrade}:
+ * ```ts
+ * this.fetchHandler = createActionFetchHandler(this.runtime, {
+ *   onWebSocketUpgrade: () => {
+ *     const pair = new WebSocketPair();
+ *     this.ctx.acceptWebSocket(pair[1]);
+ *     return new Response(null, { status: 101, webSocket: pair[0] });
+ *   },
+ * });
+ * // async fetch(request) { return this.fetchHandler(request); }
+ * ```
+ */
+declare function createActionFetchHandler(runtime: ActionRuntime, options?: IActionFetchHandlerOptions): (request: Request) => Promise<Response>;
+//#endregion
+//#region src/ActionRuntime/Handler/Server/createSecureActionServer.d.ts
+interface ISecureActionServerHandlerOptions<TConn> {
+  /** The shared channel identity (codec + dictionary version) — same one the clients use. */
+  channel: ISecureWsChannel;
+  /**
+   * Coordinate of the *connecting clients* (typically env-only, e.g. `RuntimeCoordinate.env("web_app")`),
+   * used to route results/pushes back over this handler.
+   */
+  clientEnv: RuntimeCoordinate;
+  /** This server's runtime — its coordinate is the server identity presented in the handshake. */
+  runtime: ActionRuntime;
+  /**
+   * One backing store for the server's crypto identity *and* its trust-on-first-use verify-key pins.
+   * Their keys don't collide, so a single adapter is enough; back it with persistent storage (e.g. a
+   * Durable Object's storage) so identity and pins survive eviction.
+   */
+  storageAdapter: StorageAdapter;
+  /** Write an encoded frame to a specific live connection (e.g. `(ws, frame) => ws.send(frame)`). */
+  send: (connection: TConn, frame: string | Uint8Array | ArrayBuffer) => void;
+  /** Accepted level(s); defaults to negotiating any of none/authenticated/encrypted. */
+  securityLevel?: ESecurityLevel | readonly ESecurityLevel[];
+  /** Trust decision for a client's verify key; defaults to storage-backed TOFU over `storageAdapter`. */
+  verifyKeyResolver?: IClientVerifyKeyResolver;
+  /** Timeout (ms) applied to server-initiated actions awaiting a client response. */
+  defaultTimeout?: number;
+}
+/**
+ * Build an {@link ActionServerHandler} for the secure binary channel with the boilerplate folded in:
+ * it creates the {@link ClientCryptoKeyLink} and the storage-backed TOFU resolver from a single
+ * `storageAdapter`, installs the channel's per-connection codec, and assembles the `security` block
+ * from the runtime coordinate + channel version (accepting all three levels by default).
+ *
+ * For a hibernatable transport (e.g. a Durable Object), pair it with
+ * {@link createHibernatableWsServerAdapter} to wire persistence + replay.
+ */
+declare function createSecureActionServerHandler<TConn = unknown>(options: ISecureActionServerHandlerOptions<TConn>): ActionServerHandler<TConn>;
+interface IHibernatableWsServerAdapterOptions<TConn> {
+  /** The handler to drive (from {@link createSecureActionServerHandler} or `createServerHandler`). */
+  handler: ActionServerHandler<TConn>;
+  /** All currently-live connections — replayed on construction to rebuild bindings after a wake. */
+  getWebSockets: () => TConn[];
+  /** Read a connection's persisted binding (e.g. `(ws) => ws.deserializeAttachment()`). */
+  getAttachment: (connection: TConn) => IActionServerConnectionBinding | undefined;
+  /** Persist a connection's binding when it is bound (e.g. `(ws, b) => ws.serializeAttachment(b)`). */
+  setAttachment: (connection: TConn, binding: IActionServerConnectionBinding) => void;
+}
+interface IHibernatableWsServerAdapter<TConn> {
+  /** Feed one inbound frame from a connection into the handler. */
+  receive: (connection: TConn, frame: string | ArrayBuffer | Uint8Array) => void;
+  /** Forget a connection (call on socket close/error). */
+  drop: (connection: TConn) => void;
+}
+/**
+ * Wire the hibernation lifecycle for a server handler on a transport whose sockets outlive process
+ * eviction (e.g. a Durable Object's hibernatable WebSockets). It owns persistence end to end:
+ * registers `setAttachment` as the handler's connection-bound callback and immediately replays every
+ * live connection's stored binding via `getAttachment`, so results/pushes still route after a wake.
+ *
+ * Construct it once when the handler is built, then forward socket events:
+ * ```ts
+ * const wsServer = createHibernatableWsServerAdapter({ handler, getWebSockets, getAttachment, setAttachment });
+ * // webSocketMessage(ws, msg) => wsServer.receive(ws, msg);
+ * // webSocketClose/Error(ws)  => wsServer.drop(ws);
+ * ```
+ */
+declare function createHibernatableWsServerAdapter<TConn>(options: IHibernatableWsServerAdapterOptions<TConn>): IHibernatableWsServerAdapter<TConn>;
+//#endregion
+//#region src/errors/err_nice_action.d.ts
+declare enum EErrId_NiceAction {
+  not_implemented = "not_implemented",
+  action_id_not_in_domain = "action_id_not_in_domain",
+  domain_already_exists_in_hierarchy = "domain_already_exists_in_hierarchy",
+  domain_no_handler = "domain_no_handler",
+  hydration_domain_mismatch = "hydration_domain_mismatch",
+  hydration_action_state_mismatch = "hydration_action_state_mismatch",
+  hydration_action_id_not_found = "hydration_action_id_not_found",
+  no_action_execution_handler = "no_action_execution_handler",
+  wire_action_not_payload = "wire_action_not_payload",
+  wire_not_action_data = "wire_not_action_data",
+  client_runtime_already_registered = "client_runtime_already_registered",
+  client_runtime_not_registered = "client_runtime_not_registered",
+  runtime_reset = "runtime_reset",
+  no_client_runtimes_registered = "no_client_runtimes_registered",
+  action_input_validation_failed = "action_input_validation_failed",
+  action_input_validation_promise = "action_input_validation_promise",
+  action_output_validation_failed = "action_output_validation_failed",
+  action_output_validation_promise = "action_output_validation_promise"
+}
+declare const err_nice_action: import("@nice-code/error").NiceErrorDomain<{
+  domain: string;
+  allDomains: [string, "err_nice"];
+  schema: {
+    not_implemented: import("@nice-code/error").INiceErrorIdMetadata<{
+      label: string;
+    }, import("@nice-code/error").JSONSerializableValue>;
+    action_id_not_in_domain: import("@nice-code/error").INiceErrorIdMetadata<{
+      domain: string;
+      actionId: string;
+    }, import("@nice-code/error").JSONSerializableValue>;
+    domain_already_exists_in_hierarchy: import("@nice-code/error").INiceErrorIdMetadata<{
+      domain: string;
+      allParentDomains: string[];
+      parentDomain: string;
+    }, import("@nice-code/error").JSONSerializableValue>;
+    domain_no_handler: import("@nice-code/error").INiceErrorIdMetadata<{
+      domain: string;
+    }, import("@nice-code/error").JSONSerializableValue>;
+    hydration_domain_mismatch: import("@nice-code/error").INiceErrorIdMetadata<{
+      expected: string;
+      received: string;
+    }, import("@nice-code/error").JSONSerializableValue>;
+    hydration_action_state_mismatch: import("@nice-code/error").INiceErrorIdMetadata<{
+      expected: string;
+      received: string;
+    }, import("@nice-code/error").JSONSerializableValue>;
+    hydration_action_id_not_found: import("@nice-code/error").INiceErrorIdMetadata<{
+      domain: string;
+      actionId: string;
+    }, import("@nice-code/error").JSONSerializableValue>;
+    no_action_execution_handler: import("@nice-code/error").INiceErrorIdMetadata<{
+      domain: string;
+      actionId: string;
+      specifiedClient?: RuntimeCoordinate;
+    }, import("@nice-code/error").JSONSerializableValue>;
+    wire_action_not_payload: import("@nice-code/error").INiceErrorIdMetadata<{
+      domain: string;
+      actionId: string;
+      actionState: string | undefined;
+    }, import("@nice-code/error").JSONSerializableValue>;
+    wire_not_action_data: import("@nice-code/error").INiceErrorIdMetadata<any, import("@nice-code/error").JSONSerializableValue>;
+    runtime_reset: import("@nice-code/error").INiceErrorIdMetadata<any, import("@nice-code/error").JSONSerializableValue>;
+    client_runtime_already_registered: import("@nice-code/error").INiceErrorIdMetadata<{
+      context?: IActionRuntimeManagerContext;
+      client: RuntimeCoordinate;
+    }, import("@nice-code/error").JSONSerializableValue>;
+    client_runtime_not_registered: import("@nice-code/error").INiceErrorIdMetadata<{
+      context?: IActionRuntimeManagerContext;
+      clientStringId: TRuntimeCoordinateStringId;
+    }, import("@nice-code/error").JSONSerializableValue>;
+    no_client_runtimes_registered: import("@nice-code/error").INiceErrorIdMetadata<{
+      context?: IActionRuntimeManagerContext;
+    }, import("@nice-code/error").JSONSerializableValue>;
+    action_input_validation_failed: import("@nice-code/error").INiceErrorIdMetadata<{
+      domain: string;
+      actionId: string;
+      validationMessage: string;
+    }, import("@nice-code/error").JSONSerializableValue>;
+    action_input_validation_promise: import("@nice-code/error").INiceErrorIdMetadata<{
+      domain: string;
+      actionId: string;
+    }, import("@nice-code/error").JSONSerializableValue>;
+    action_output_validation_failed: import("@nice-code/error").INiceErrorIdMetadata<{
+      domain: string;
+      actionId: string;
+      validationMessage: string;
+    }, import("@nice-code/error").JSONSerializableValue>;
+    action_output_validation_promise: import("@nice-code/error").INiceErrorIdMetadata<{
+      domain: string;
+      actionId: string;
+    }, import("@nice-code/error").JSONSerializableValue>;
+  };
+}>;
+//#endregion
+//#region src/utils/decodeActionFrame.d.ts
+/**
+ * Minimal codec shape needed to turn an incoming channel frame back into action wire JSON. Matches
+ * the `formatMessage` object the WebSocket transport (and `createBinaryWsAdapter`) provide.
+ */
+interface IActionFrameDecoder {
+  incoming?: (frame: string | ArrayBuffer | Uint8Array | Blob) => TActionPayload_Any_JsonObject<any, any> | undefined;
+}
+/**
+ * Decode a single inbound channel frame (text or binary) into validated action wire JSON, or
+ * `undefined` if it isn't a recognisable action payload.
+ *
+ * Shared by the WebSocket transport's message listener and the server-side `ActionServerHandler` so
+ * both decode identically: a binary `decoder.incoming` (e.g. msgpackr) takes precedence, and plain
+ * text frames fall back to JSON — keeping binary and JSON clients interoperable on one channel.
+ */
+declare function decodeActionFrame(frame: string | ArrayBuffer | Uint8Array, decoder?: IActionFrameDecoder): TActionPayload_Any_JsonObject<any, any> | undefined;
+//#endregion
+//#region src/utils/isActionPayload_Any_JsonObject.d.ts
+declare function isActionPayload_Any_JsonObject(obj: unknown): obj is TActionPayload_Any_JsonObject;
+//#endregion
+//#region src/utils/isActionPayload_Request_JsonObject.d.ts
+declare const isActionPayload_Request_JsonObject: (obj: unknown) => obj is IActionPayload_Request_JsonObject;
+//#endregion
+//#region src/utils/isActionPayload_Result_JsonObject.d.ts
+declare const isActionPayload_Result_JsonObject: (obj: unknown) => obj is IActionPayload_Result_JsonObject;
+//#endregion
+//#region src/ActionDefinition/Action/Payload/ActionPayload.types.d.ts
+declare enum EActionPayloadType {
+  request = "request",
+  progress = "progress",
+  result = "result",
+  stream = "stream",
+  push = "push"
+}
+interface IActionPayload_Data_Base {
+  time: number;
+}
+interface IActionPayload_Base<DT extends EActionPayloadType, DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string> extends IActionBase<EActionForm.data, DOM, ID>, IActionPayload_Data_Base {
+  readonly type: DT;
+  readonly context: ActionContext<DOM, ID>;
+}
+type IActionRouteItemHandler = IActionHandler_Local_Json | (IActionHandler_ExternalClient_Json & {
+  transType: ETransportType;
+  transOrd: number;
+  transInfo?: ITransportRouteInfo;
+});
+/**
+ *  [                        ]
+ *  [  ACTION PAYLOAD TYPES  ]
+ *  [                        ]
+ */
+/**
+ *
+ *  [ RESULT ]
+ *
+ */
+type TActionResultOutcome<OUT, ERR> = {
+  ok: true;
+  output: OUT;
+} | {
+  ok: false;
+  error: ERR;
+};
+interface IActionPayload_Result<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string> extends IActionPayload_Base<EActionPayloadType.result, DOM, ID> {
+  readonly result: TActionResultOutcome<TInferOutputFromSchema<DOM["actionSchema"][ID]>["Output"], TInferActionError<DOM["actionSchema"][ID]>>;
+}
+/**
+ *
+ *  [ PROGRESS ]
+ *
+ */
+declare enum EActionProgressType {
+  none = "none",
+  percentage = "percentage",
+  custom = "custom"
+}
+interface IActionProgress_None {
+  type: EActionProgressType.none;
+}
+interface IActionProgress_Percentage {
+  type: EActionProgressType.percentage;
+  progress: number;
+  message?: string;
+}
+interface IActionProgress_Custom {
+  type: EActionProgressType.custom;
+  data: any;
+}
+type TActionProgress = IActionProgress_None | IActionProgress_Percentage | IActionProgress_Custom;
+interface IActionPayload_Progress<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string> extends IActionPayload_Base<EActionPayloadType.progress, DOM, ID> {
+  readonly progress: TActionProgress;
+}
+/**
+ *
+ *  [                   ]
+ *  [  Wire JSON types  ]
+ *  [                   ]
+ *
+ */
+interface IActionPayload_Base_JsonObject<DT extends EActionPayloadType, DOM extends IActionDomain = IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> extends IActionBase_JsonObject<EActionForm.data, DOM, ID> {
+  type: DT;
+  context: IActionContext_Data_JsonObject;
+  time: number;
+}
+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;
+}
+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;
+  progress: TActionProgress;
+}
+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]>["SerdeOutput"], TInferActionError<DOM["actionSchema"][ID]>>;
+  outputHash: string;
+}
+/**
+ *
+ *  [                  ]
+ *  [  COMBINED TYPES  ]
+ *  [                  ]
+ *
+ */
+type TActionPayload_Any_Instance<DOM extends IActionDomain = IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> = ActionPayload_Request<DOM, ID> | ActionPayload_Result<DOM, ID> | ActionPayload_Progress<DOM, ID>;
+type TActionPayload_Any_JsonObject<DOM extends IActionDomain = IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> = IActionPayload_Request_JsonObject<DOM, ID> | IActionPayload_Progress_JsonObject<DOM, ID> | IActionPayload_Result_JsonObject<DOM, ID>;
+//#endregion
+export { createBinaryWsAdapter as $, TInferOutputFromSchema as $n, ITransportDispatchAction as $t, createSecureActionServerHandler as A, ERunningActionState as An, ICustomTransportSendOptions as At, IConnectionAttachment as B, IRuntimeCoordinate as Bn, MaybePromise as Bt, decodeActionFrame as C, TUpdateActionRunConfig as Cn, IHttpTransportOptions as Ct, IHibernatableWsServerAdapterOptions as D, IActionCore as Dn, err_nice_transport as Dt, IHibernatableWsServerAdapter as E, ActionPayload_Request as En, EErrId_NiceTransport as Et, IActionServerHandlerOptions as F, IRunningActionUpdate_Success as Fn, ActionDomain as Ft, createSecureWebSocketTransport as G, TRuntimeCoordinateStringId as Gn, ETransportStatus as Gt, WsConnectionStateStore as H, IRuntimeFullCoordinates as Hn, createExternalClientHandler as Ht, TActionChannelFormatMessage as I, TRunningActionUpdate as In, ActionRootDomain as It, IWebSocketTransportSocketOptions as J, IActionRootDomain as Jn, IActionTransportInitialized as Jt, defineSecureWsChannel as K, IActionDomain as Kn, ETransportType as Kt, TActionConnectionEncoding as L, TRunningActionUpdateFinished as Ln, ActionRuntime as Lt, createActionFetchHandler as M, IRunningActionUpdate_Abort as Mn, err_nice_external_client as Mt, ActionServerHandler as N, IRunningActionUpdate_Progress as Nn, createActionRootDomain as Nt, ISecureActionServerHandlerOptions as O, IActionCore_JsonObject as On, CustomTransport as Ot, IActionServerConnectionBinding as P, IRunningActionUpdate_Started as Pn, ActionCore as Pt, createBinaryWsSessionFactory as Q, TInferInputFromSchema as Qn, IActionTransportResolvers as Qt, TServerConnectionCaseFn as R, TRunningActionUpdateListener as Rn, ActionLocalHandler as Rt, IActionFrameDecoder as S, TTransportStatusInfo_GetTransport_Output as Sn, HttpTransport as St, err_nice_action as T, ActionPayload_Progress as Tn, err_nice_transport_ws as Tt, ISecureWebSocketTransportOptions as U, RuntimeCoordinate as Un, ITransportConnectionContext as Ut, IWsConnectionStateStoreOptions as V, IRuntimeCoordinateSpecifics as Vn, ActionExternalClientHandler as Vt, ISecureWsChannel as W, TRuntimeCoordinateEnvId as Wn, Transport as Wt, WebSocketTransport as X, TActionDomainSchema as Xn, IActionTransportReadyData_Base as Xt, TWebSocketTransportOptions as Y, TActionDomainChildDef as Yn, IActionTransportReady as Yt, IBinaryWsSessionOptions as Z, TDomainActionId as Zn, IActionTransportReadyData_Methods as Zt, TActionProgress as _, TSendActionDataMethod as _n, encodeHandshakeMessage as _t, IActionPayload_Data_Base as a, ITransportStatusInfo_Failed as an, TActionSchemaOptions as ar, IClientHandshakeConfig as at, isActionPayload_Request_JsonObject as b, TTransportInitializationFinishedInfo as bn, IActionFrameCryptoConfig as bt, IActionPayload_Request_JsonObject as c, ITransportStatusInfo_Unsupported as cn, IHandshakeEncryptionKeyMaterial as ct, IActionProgress_Custom as d, TOnResolveAnyIncomingActionData as dn, THandshakeMessage as dt, ITransportMethod_SendActionData_Input as en, TPossibleDomainId as er, IActionTransportDef_Ws as et, IActionProgress_None as f, TOnResolveAnyIncomingActionData_Json as fn, createClientHandshake as ft, TActionPayload_Any_JsonObject as g, TOnResolveIncomingResponseJson as gn, decodeHandshakeMessage as gt, TActionPayload_Any_Instance as h, TOnResolveIncomingResponse as hn, createStorageTofuVerifyKeyResolver as ht, IActionPayload_Base_JsonObject as i, ITransportStatusInfo_Base as in, actionSchema as ir, ESecurityLevel as it, IActionFetchHandlerOptions as j, ERunningActionUpdateType as jn, TCustomTransportOptions as jt, createHibernatableWsServerAdapter as k, ERunningActionFinishedType as kn, ICustomTransportAdvancedOptions as kt, IActionPayload_Result as l, IUpdateActionRunConfig_Output as ln, IHandshakeResult as lt, IActionRouteItemHandler as m, TOnResolveIncomingRequestJson as mn, createServerHandshake as mt, EActionProgressType as n, ITransportRouteClientParams as nn, ActionSchema as nr, IActionTransportReadyData_Ws as nt, IActionPayload_Progress as o, ITransportStatusInfo_Initializing as on, TActionSerializationDefinition as or, IClientVerifyKeyResolveInput as ot, IActionProgress_Percentage as p, TOnResolveIncomingRequest as pn, createInMemoryTofuVerifyKeyResolver as pt, IWebSocketTransportAdvancedOptions as q, IActionDomainChildOptions as qn, IActionTransportDef as qt, IActionPayload_Base as r, ITransportRouteInfo as rn, TInferActionError as rr, EHandshakeMessageType as rt, IActionPayload_Progress_JsonObject as s, ITransportStatusInfo_Ready as sn, TTransportedValue as sr, IClientVerifyKeyResolver as st, EActionPayloadType as t, ITransportRouteActionParams as tn, TPossibleDomainIdList as tr, IActionTransportInitialized_Ws as tt, IActionPayload_Result_JsonObject as u, TGetTransportFn as un, IServerHandshakeConfig as ut, TActionResultOutcome as v, TSendReturnDataMethod as vn, runtimeLinkId as vt, EErrId_NiceAction as w, RunningAction as wn, EErrId_NiceTransport_WebSocket as wt, isActionPayload_Any_JsonObject as x, TTransportStatusInfo as xn, createActionFrameCrypto as xt, isActionPayload_Result_JsonObject as y, TTransportCache as yn, IActionFrameCrypto as yt, createServerHandler as z, ActionPayload_Result as zn, createLocalHandler as zt };
+//# sourceMappingURL=ActionPayload.types-D28ELKXC.d.ts.map