@ic-reactor/core 2.0.1 → 3.0.0-beta.2

package/dist/utils/polling.js

@@ -0,0 +1,170 @@
+/**
+ * @module polling
+ * @description
+ * Polling strategy for Internet Computer (Dfinity) agent update calls.
+ *
+ * This module provides a configurable, intelligent polling mechanism that:
+ * - Starts with rapid polling for quick responses (fast phase)
+ * - Gradually increases delay intervals (ramp phase)
+ * - Settles into steady-state polling (plateau phase)
+ * - Adds jitter to prevent thundering herd problems
+ * - Provides structured logging with elapsed time and status
+ * - Supports graceful cancellation via AbortSignal
+ *
+ * @example
+ * ```typescript
+ * const strategy = createPollingStrategy({
+ *   context: "signer-creation",
+ *   fastAttempts: 10,
+ *   plateauDelayMs: 5000
+ * });
+ *
+ * const result = await actor.createSigner(params, {
+ *   pollingOptions: { strategy }
+ * });
+ * ```
+ */
+import { RequestStatusResponseStatus, } from "@icp-sdk/core/agent";
+/**
+ * Creates an polling strategy for Internet Computer agent update calls.
+ *
+ * The strategy implements three phases:
+ * 1. **Fast Phase**: Initial rapid polling (default: 10 attempts @ 100ms intervals)
+ * 2. **Ramp Phase**: Exponential backoff growth (default: up to 20s elapsed)
+ * 3. **Plateau Phase**: Steady-state polling (default: 5s intervals)
+ *
+ * The strategy continues polling while request status is RECEIVED/PROCESSING,
+ * and only terminates on REPLIED/REJECTED/DONE status or when aborted.
+ *
+ * @param {PollingConfig} [cfg={}] - Configuration options
+ * @returns {PollStrategy} - Async strategy function compatible with agent pollingOptions.strategy
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const strategy = createPollingStrategy();
+ *
+ * // Custom configuration for long-running operations
+ * const strategy = createPollingStrategy({
+ *   context: "blockchain-sync",
+ *   fastAttempts: 5,
+ *   fastDelayMs: 200,
+ *   rampUntilMs: 30_000,
+ *   plateauDelayMs: 10_000,
+ *   jitterRatio: 0.3
+ * });
+ *
+ * // With abort signal
+ * const controller = new AbortController();
+ * const strategy = createPollingStrategy({
+ *   context: "transaction-signing",
+ *   abortSignal: controller.signal
+ * });
+ * // Later: controller.abort();
+ * ```
+ *
+ * @throws {Error} When abortSignal is triggered during polling
+ */
+export function createPollingStrategy(cfg = {}) {
+    const { context = "operation", logPrefix = "[Polling]", fastAttempts = 10, fastDelayMs = 100, rampUntilMs = 20000, plateauDelayMs = 5000, jitterRatio = 0.4, maxLogIntervalMs = 15000, abortSignal, } = cfg;
+    let attempt = 0;
+    const start = Date.now();
+    let lastLog = 0;
+    /**
+     * Structured logging function that outputs polling state information.
+     * Implements intelligent log throttling to prevent console spam while ensuring
+     * periodic heartbeat logs for long-running operations.
+     *
+     * @param {string} phase - Current polling phase ("fast", "ramp", or "plateau")
+     * @param {string | undefined} statusKind - Request status from IC agent
+     * @param {number} nextDelay - Calculated delay until next poll (ms)
+     */
+    const log = (phase, statusKind, nextDelay) => {
+        const now = Date.now();
+        // Suppress ultra-noisy logs: skip if < 1s since last log and not in fast phase
+        if (now - lastLog < 1000 && phase !== "fast" && nextDelay < 1000)
+            return;
+        // Force a heartbeat log if too much time has passed (prevents silent operations)
+        if (now - lastLog > maxLogIntervalMs) {
+            phase += "+heartbeat";
+        }
+        lastLog = now;
+        // eslint-disable-next-line no-console
+        console.info(`${logPrefix} ${context} attempt=${attempt} elapsed=${now - start}ms status=${statusKind} phase=${phase} nextDelay=${Math.round(nextDelay)}ms`);
+    };
+    /**
+     * Computes the next polling delay based on elapsed time and attempt count.
+     * Implements three-phase strategy:
+     * - Fast: Initial rapid polling
+     * - Ramp: Exponential growth with power curve
+     * - Plateau: Steady-state polling
+     *
+     * @param {number} elapsed - Milliseconds elapsed since start
+     * @param {number} a - Current attempt number
+     * @returns {{ delay: number; phase: string }} - Calculated delay and phase name
+     */
+    const computeDelay = (elapsed, a) => {
+        // Phase 1: Fast initial polling
+        if (a < fastAttempts) {
+            return { delay: withJitter(fastDelayMs), phase: "fast" };
+        }
+        // Phase 2: Ramp with exponential growth (power curve 0.7 for smooth acceleration)
+        if (elapsed < rampUntilMs) {
+            const progress = elapsed / rampUntilMs; // Normalized progress: 0..1
+            const base = fastDelayMs + (plateauDelayMs - fastDelayMs) * Math.pow(progress, 0.7);
+            return { delay: withJitter(base), phase: "ramp" };
+        }
+        // Phase 3: Plateau - steady-state polling
+        return { delay: withJitter(plateauDelayMs), phase: "plateau" };
+    };
+    /**
+     * Applies random jitter to prevent synchronized polling across multiple clients.
+     * Uses configured jitterRatio to add ±N% randomness to the base delay.
+     *
+     * @param {number} base - Base delay in milliseconds
+     * @returns {number} - Jittered delay, minimum 50ms
+     */
+    const withJitter = (base) => {
+        const spread = base * jitterRatio;
+        return Math.max(50, base - spread + Math.random() * spread * 2);
+    };
+    /**
+     * Async strategy function invoked by the IC agent on each polling cycle.
+     * Determines whether to continue waiting based on request status.
+     *
+     * @param {Principal} _canisterId - Target canister principal (unused but required by interface)
+     * @param {RequestId} _requestId - Request identifier (unused but required by interface)
+     * @param {RequestStatusResponseStatus} [rawStatus] - Current request status from IC
+     * @returns {Promise<void>} - Resolves after calculated delay, or immediately for terminal states
+     * @throws {Error} - If abortSignal is triggered
+     */
+    return async function strategy(_canisterId, _requestId, rawStatus) {
+        // Check for external cancellation
+        if (abortSignal?.aborted) {
+            throw new Error(`${context} polling aborted`);
+        }
+        attempt++;
+        const statusKind = rawStatus;
+        // Terminal states: Stop polling immediately
+        // - Replied: Request completed successfully
+        // - Rejected: Request was rejected by canister
+        // - Done: Request processing complete
+        // Note: Agent typically stops before we reach here, but we handle defensively
+        if (statusKind === RequestStatusResponseStatus.Replied ||
+            statusKind === RequestStatusResponseStatus.Rejected ||
+            statusKind === RequestStatusResponseStatus.Done) {
+            return;
+        }
+        // Continue polling for:
+        // - Received: Request received but not yet processed
+        // - Processing: Request is being processed
+        // - Unknown: Status not yet available
+        // - undefined: No status information yet
+        const elapsed = Date.now() - start;
+        const { delay, phase } = computeDelay(elapsed, attempt);
+        log(phase, statusKind, delay);
+        // Sleep for calculated delay before next poll
+        await new Promise((r) => setTimeout(r, delay));
+    };
+}
+//# sourceMappingURL=polling.js.map

package/dist/utils/polling.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"polling.js","sourceRoot":"","sources":["../../src/utils/polling.ts"],"names":[],"mappings":"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"}

package/dist/version.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Library version - automatically synced from package.json.
+ */
+export declare const VERSION = "3.0.0";
+//# sourceMappingURL=version.d.ts.map

package/dist/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,OAAO,UAAU,CAAA"}

package/dist/version.js

@@ -0,0 +1,5 @@
+/**
+ * Library version - automatically synced from package.json.
+ */
+export const VERSION = "3.0.0";
+//# sourceMappingURL=version.js.map

package/dist/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,OAAO,CAAA"}

package/package.json

@@ -1,60 +1,86 @@
 {
   "name": "@ic-reactor/core",
-  "version": "2.0.1",
-  "description": "A library for intracting with the Internet Computer canisters",
+  "version": "3.0.0-beta.2",
+  "description": "IC Reactor Core Library",
   "main": "dist/index.js",
+  "module": "dist/index.js",
   "types": "dist/index.d.ts",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
   "files": [
-    "dist/*"
+    "dist",
+    "README.md"
   ],
+  "scripts": {
+    "build": "rm -rf dist tsconfig.tsbuildinfo && tsc -b",
+    "test": "vitest run",
+    "version:sync": "node -e \"const pkg = require('./package.json'); const fs = require('fs'); fs.writeFileSync('./src/version.ts', '/**\\n * Library version - automatically synced from package.json.\\n */\\nexport const VERSION = \\\"' + pkg.version + '\\\"\\n');\"",
+    "size": "size-limit",
+    "analyze": "size-limit --why"
+  },
   "repository": {
     "type": "git",
-    "url": "git@github.com:B3Pay/ic-reactor.git"
+    "url": "https://github.com/B3Pay/ic-reactor",
+    "directory": "packages/core"
   },
+  "bugs": {
+    "url": "https://github.com/B3Pay/ic-reactor/issues"
+  },
+  "homepage": "https://ic-reactor.dev",
   "keywords": [
-    "actor",
-    "react",
-    "candid",
+    "internet-computer",
+    "icp",
     "dfinity",
     "web3",
-    "dapp"
+    "blockchain",
+    "canister",
+    "actor",
+    "reactor",
+    "tanstack-query"
   ],
-  "author": "b3hr4d",
+  "author": "Behrad Deylami",
   "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/b3hr4d/ic-reactor/issues"
-  },
-  "homepage": "https://b3pay.github.io/ic-reactor/modules/core.html",
   "dependencies": {
-    "@dfinity/agent": "^3.1.0",
-    "@dfinity/auth-client": "^3.1.0",
-    "@dfinity/candid": "^3.1.0",
-    "@dfinity/identity": "^3.1.0",
-    "@dfinity/principal": "^3.1.0",
-    "zustand": "5.0.6"
+    "@noble/curves": "^2.0.1",
+    "zod": "^4.3.2"
   },
   "peerDependencies": {
-    "@dfinity/agent": ">=3.1.0",
-    "@dfinity/auth-client": ">=3.1.0",
-    "@dfinity/candid": ">=3.1.0",
-    "@dfinity/identity": ">=3.1.0",
-    "@dfinity/principal": ">=3.1.0"
+    "@icp-sdk/core": "^5.0.0",
+    "@icp-sdk/auth": "^5.0.0",
+    "@tanstack/query-core": "^5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@icp-sdk/auth": {
+      "optional": true
+    },
+    "@tanstack/query-core": {
+      "optional": true
+    }
   },
   "devDependencies": {
-    "@ic-reactor/parser": "0.4.5"
+    "@icp-sdk/auth": "^5.0.0",
+    "@icp-sdk/core": "^5.0.0",
+    "@size-limit/preset-small-lib": "^11.2.0",
+    "@tanstack/query-core": "^5.90",
+    "@tanstack/react-query": "^5.90",
+    "@types/node": "^24.10.1",
+    "fake-indexeddb": "^6.2.5",
+    "size-limit": "^11.2.0",
+    "vitest": "^4.0.16"
   },
-  "scripts": {
-    "test": "bun test",
-    "start": "bun run tsc --watch",
-    "build:tsc": "bun run tsc",
-    "build": "bun run build:tsc && bun run bundle",
-    "bundle": "bun run bundle:dev && bun run bundle:prod",
-    "bundle:dev": "bun run webpack-cli --mode development",
-    "bundle:prod": "bun run webpack-cli --mode production",
-    "clean": "bun run rimraf dist && bun run rimraf umd && bun run rimraf node_modules"
-  },
-  "engines": {
-    "node": ">=22.0.0"
-  },
-  "gitHead": "1c8f5bfc6b0fea9347602beeebd6443f79d7d54e"
+  "size-limit": [
+    {
+      "name": "Core Library",
+      "path": "dist/index.js",
+      "limit": "50 KB",
+      "gzip": true
+    }
+  ]
 }

package/LICENSE.md

@@ -1,8 +0,0 @@
-The MIT License (MIT)
-Copyright © 2023 B3Pay
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/classes/actor/index.d.ts

@@ -1,34 +0,0 @@
-import type { CallConfig } from "@dfinity/agent";
-import type { ActorMethodParameters, ActorMethodReturnType, ActorStore, ActorManagerParameters, FunctionName, VisitService, BaseActor, ActorMethodState, MethodAttributes } from "./types";
-import { IDL } from "@dfinity/candid";
-import type { AgentManager } from "../agent";
-import type { UpdateAgentParameters } from "../types";
-export declare class ActorManager<A = BaseActor> {
-    private _actor;
-    private _idlFactory;
-    private _agentManager;
-    private _unsubscribeAgent;
-    private _subscribers;
-    canisterId: string;
-    actorStore: ActorStore<A>;
-    visitFunction: VisitService<A>;
-    methodAttributes: MethodAttributes<A>;
-    private updateState;
-    updateMethodState: (method: FunctionName<A>, hash: string, newState: Partial<ActorMethodState<A, typeof method>[string]>) => void;
-    constructor(actorConfig: ActorManagerParameters);
-    initialize: (options?: UpdateAgentParameters) => Promise<void>;
-    extractInterface: () => IDL.ServiceClass;
-    extractMethodAttributes: () => MethodAttributes<A>;
-    extractVisitor: () => VisitService<A>;
-    private initializeActor;
-    private _getActorMethod;
-    callMethod: <M extends FunctionName<A>>(functionName: M, ...args: ActorMethodParameters<A[M]>) => Promise<ActorMethodReturnType<A[M]>>;
-    callMethodWithOptions: (options: CallConfig) => <M extends FunctionName<A>>(functionName: M, ...args: ActorMethodParameters<A[M]>) => Promise<ActorMethodReturnType<A[M]>>;
-    call: <M extends FunctionName<A>>(functionName: M, ...args: ActorMethodParameters<A[M]>) => Promise<ActorMethodReturnType<A[M]>>;
-    get agentManager(): AgentManager;
-    getActor: () => A | null;
-    getState: ActorStore<A>["getState"];
-    subscribeActorState: ActorStore<A>["subscribe"];
-    setState: ActorStore<A>["setState"];
-    cleanup: () => void;
-}

package/dist/classes/actor/index.js

@@ -1,245 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ActorManager = void 0;
-/* eslint-disable no-console */
-const agent_1 = require("@dfinity/agent");
-const helper_1 = require("../../utils/helper");
-const candid_1 = require("@dfinity/candid");
-const ACTOR_INITIAL_STATE = {
-    name: "",
-    version: 0,
-    methodState: {},
-    initializing: false,
-    isInitializing: false,
-    initialized: false,
-    isInitialized: false,
-    error: undefined,
-};
-class ActorManager {
-    _actor = null;
-    _idlFactory;
-    _agentManager;
-    _unsubscribeAgent;
-    _subscribers = [];
-    canisterId;
-    actorStore;
-    visitFunction;
-    methodAttributes;
-    updateState = (newState, action) => {
-        this.actorStore.setState((state) => ({ ...state, ...newState }), false, action);
-    };
-    updateMethodState = (method, hash, newState) => {
-        const actionName = `${method}:${newState.error ? "error" : newState.isLoading ? "loading..." : "loaded"}`;
-        this.actorStore.setState((state) => {
-            const methodState = state.methodState[method] || {};
-            const currentMethodState = methodState[hash] || DEFAULT_STATE;
-            const updatedMethodState = {
-                ...methodState,
-                [hash]: { ...currentMethodState, ...newState },
-            };
-            return {
-                ...state,
-                methodState: {
-                    ...state.methodState,
-                    [method]: updatedMethodState,
-                },
-            };
-        }, false, actionName);
-    };
-    constructor(actorConfig) {
-        const { agentManager, idlFactory, canisterId, name = canisterId.toString(), withVisitor = false, withDevtools = false, initializeOnCreate = true, } = actorConfig;
-        if (!canisterId) {
-            throw new agent_1.AgentError(new agent_1.UnexpectedErrorCode("CanisterId is required!"), agent_1.ErrorKindEnum.Unknown);
-        }
-        this.canisterId = canisterId.toString();
-        if (!idlFactory) {
-            throw new agent_1.AgentError(new agent_1.UnexpectedErrorCode("IDLFactory is required!"), agent_1.ErrorKindEnum.Unknown);
-        }
-        this._idlFactory = idlFactory;
-        this.methodAttributes = this.extractMethodAttributes();
-        if (!agentManager) {
-            throw new agent_1.AgentError(new agent_1.UnexpectedErrorCode("AgentManager is required!"), agent_1.ErrorKindEnum.Unknown);
-        }
-        this._agentManager = agentManager;
-        // Initialize stores
-        this.actorStore = (0, helper_1.createStoreWithOptionalDevtools)({ ...ACTOR_INITIAL_STATE, name }, {
-            withDevtools,
-            name: "reactor-actor",
-            store: canisterId.toString(),
-        });
-        this._unsubscribeAgent = this._agentManager.subscribeAgent(this.initializeActor, initializeOnCreate);
-        if (withVisitor) {
-            this.visitFunction = this.extractVisitor();
-        }
-        else {
-            this.visitFunction = emptyVisitor;
-        }
-    }
-    initialize = async (options) => {
-        await this._agentManager.updateAgent(options);
-    };
-    extractInterface = () => {
-        return this._idlFactory({ IDL: candid_1.IDL });
-    };
-    extractMethodAttributes = () => {
-        const iface = this.extractInterface();
-        const methodAttributesArray = iface._fields.map(([name, func]) => ({
-            name: name,
-            attributes: {
-                numberOfArgs: func.argTypes.length,
-                type: ((0, helper_1.isQuery)(func) ? "query" : "update"),
-                validate: (arg) => func.argTypes.some((t, i) => t.covariant(arg[i])),
-            },
-        }));
-        methodAttributesArray.sort((a, b) => {
-            if (a.attributes.type === b.attributes.type) {
-                return a.attributes.numberOfArgs - b.attributes.numberOfArgs;
-            }
-            return a.attributes.type === "query" ? -1 : 1;
-        });
-        return methodAttributesArray.reduce((acc, { name, attributes }) => {
-            acc[name] = attributes;
-            return acc;
-        }, {});
-    };
-    extractVisitor = () => {
-        const iface = this.extractInterface();
-        return iface._fields.reduce((acc, service) => {
-            const functionName = service[0];
-            const type = service[1];
-            const visit = ((extractorClass, data) => {
-                return type.accept(extractorClass, data);
-            });
-            acc[functionName] = visit;
-            return acc;
-        }, {});
-    };
-    initializeActor = (agent) => {
-        const network = this._agentManager.getNetwork();
-        console.info(`Initializing actor ${this.canisterId} on ${network} network`);
-        const { _idlFactory, canisterId } = this;
-        this.updateState({
-            initializing: true,
-            isInitializing: true,
-            initialized: false,
-            isInitialized: false,
-            methodState: {},
-        }, "initializing");
-        try {
-            if (!agent) {
-                throw new agent_1.AgentError(new agent_1.UnexpectedErrorCode("Agent not initialized"), agent_1.ErrorKindEnum.Unknown);
-            }
-            this._actor = agent_1.Actor.createActor(_idlFactory, {
-                agent,
-                canisterId,
-            });
-            if (!this._actor) {
-                throw new agent_1.AgentError(new agent_1.UnexpectedErrorCode("Failed to initialize actor"), agent_1.ErrorKindEnum.Unknown);
-            }
-            this.updateState({
-                initializing: false,
-                isInitializing: false,
-                initialized: true,
-                isInitialized: true,
-            }, "initialized");
-        }
-        catch (error) {
-            console.error("Error in initializeActor:", error);
-            this.updateState({
-                error: error,
-                initializing: false,
-                isInitializing: false,
-            }, "error");
-        }
-    };
-    _getActorMethod = (functionName) => {
-        if (!this._actor) {
-            throw new agent_1.AgentError(new agent_1.UnexpectedErrorCode("Actor not initialized"), agent_1.ErrorKindEnum.Unknown);
-        }
-        if (!this._actor[functionName] ||
-            typeof this._actor[functionName] !== "function") {
-            throw new agent_1.AgentError(new agent_1.UnexpectedErrorCode(`Method ${String(functionName)} not found`), agent_1.ErrorKindEnum.Unknown);
-        }
-        return this._actor[functionName];
-    };
-    callMethod = async (functionName, ...args) => {
-        const method = this._getActorMethod(functionName);
-        const data = await method(...args);
-        return data;
-    };
-    callMethodWithOptions = (options) => {
-        return async (functionName, ...args) => {
-            const method = this._getActorMethod(functionName);
-            const data = await method.withOptions(options)(...args);
-            return data;
-        };
-    };
-    call = async (functionName, ...args) => {
-        const requestHash = (0, helper_1.generateRequestHash)(args);
-        try {
-            this.updateMethodState(functionName, requestHash, {
-                loading: true,
-                isLoading: true,
-                error: undefined,
-            });
-            const data = await this.callMethod(functionName, ...args);
-            this.updateMethodState(functionName, requestHash, {
-                loading: false,
-                isLoading: false,
-                data,
-            });
-            return data;
-        }
-        catch (error) {
-            this.updateMethodState(functionName, requestHash, {
-                loading: false,
-                isLoading: false,
-                error: error,
-                data: undefined,
-            });
-            throw error;
-        }
-    };
-    // agent store
-    get agentManager() {
-        return this._agentManager;
-    }
-    // actor store
-    getActor = () => {
-        return this._actor;
-    };
-    getState = () => {
-        return this.actorStore.getState();
-    };
-    // @ts-expect-error: Overrides subscribe method signature
-    subscribeActorState = (selectorOrListener, listener, options) => {
-        let unsubscribe = helper_1.noop;
-        if (listener) {
-            unsubscribe = this.actorStore.subscribe(selectorOrListener, listener, options);
-        }
-        else {
-            unsubscribe = this.actorStore.subscribe(selectorOrListener);
-        }
-        this._subscribers.push(unsubscribe);
-        return unsubscribe;
-    };
-    setState = (updater) => {
-        return this.actorStore.setState(updater);
-    };
-    cleanup = () => {
-        this._unsubscribeAgent();
-        this._subscribers.forEach((unsubscribe) => unsubscribe());
-    };
-}
-exports.ActorManager = ActorManager;
-const emptyVisitor = new Proxy({}, {
-    get: function (_, prop) {
-        throw new agent_1.AgentError(new agent_1.UnexpectedErrorCode(`Cannot visit function "${String(prop)}" without initializing the actor with the visitor option, please set the withVisitor option to true when creating the actor manager.`), agent_1.ErrorKindEnum.Unknown);
-    },
-});
-const DEFAULT_STATE = {
-    data: undefined,
-    error: undefined,
-    loading: false,
-    isLoading: false,
-};