@actor-system/ask 0.0.18 → 0.1.0

package/dist/ask-sync.d.ts

@@ -1,10 +1,6 @@
 import { ActorRef } from '@actor-system/core';
 import { CreateRequest } from './ask-with-callback.js';
 
-interface AskSyncOptions<out Req, in Res> {
-    to: ActorRef<Req>;
-    request: CreateRequest<Req, Res>;
-}
 /**
  * If an actor's mailbox uses a synchronous processing strategy,
  * this function can be used to perform an ask operation synchronously.
@@ -16,7 +12,6 @@ interface AskSyncOptions<out Req, in Res> {
  * - The actor is dead/stopped (and no tombstone response is available).
  * - The ask operation does not receive a response immediately.
  */
-declare const askSync: <const Req, Res>(options: AskSyncOptions<Req, Res>) => Res;
+declare const askSync: <const Req, Res>(to: ActorRef<Req>, request: CreateRequest<Req, Res>) => Res;
 
 export { askSync };
-export type { AskSyncOptions };

package/dist/ask-sync.internal.d.ts

@@ -1,10 +1,6 @@
 import { ActorRef } from '@actor-system/core/internal';
 import { CreateRequest } from './ask-with-callback.internal.js';
 
-interface AskSyncOptions<out Req, in Res> {
-    to: ActorRef<Req>;
-    request: CreateRequest<Req, Res>;
-}
 /**
  * If an actor's mailbox uses a synchronous processing strategy,
  * this function can be used to perform an ask operation synchronously.
@@ -16,7 +12,6 @@ interface AskSyncOptions<out Req, in Res> {
  * - The actor is dead/stopped (and no tombstone response is available).
  * - The ask operation does not receive a response immediately.
  */
-declare const askSync: <const Req, Res>(options: AskSyncOptions<Req, Res>) => Res;
+declare const askSync: <const Req, Res>(to: ActorRef<Req>, request: CreateRequest<Req, Res>) => Res;
 
 export { askSync };
-export type { AskSyncOptions };

package/dist/ask-sync.js

@@ -1,7 +1,12 @@
-import { PriorityScheduler, LocalActorRef, SchedulerType } from '@actor-system/core';
+import { isActorLookup } from '@actor-system/core';
+import { sync } from '@actor-system/scheduler';
 import { _askWithCallback } from './ask-with-callback.js';
-import { UnsupportedSyncOperationError, ReentryError, DisconnectedError, NoSynchronousResponseError, AskTimeoutError } from './errors.js';
+import { UnsupportedSyncOperationError, NoSynchronousResponseError, AskTimeoutError } from './errors.js';
 
+const profile = {
+    lane: sync,
+    budget: { throughput: Infinity, deadline: Infinity },
+};
 /**
  * If an actor's mailbox uses a synchronous processing strategy,
  * this function can be used to perform an ask operation synchronously.
@@ -13,13 +18,13 @@ import { UnsupportedSyncOperationError, ReentryError, DisconnectedError, NoSynch
  * - The actor is dead/stopped (and no tombstone response is available).
  * - The ask operation does not receive a response immediately.
  */
-const askSync = (options) => {
-    assertsActorSupportsSync(options.to);
-    assertsActorIsIdle(options.to);
+const askSync = (to, request) => {
+    assertsActorSupportsSync(to);
     let msgRef = null;
     let error;
     _askWithCallback({
-        ...options,
+        to,
+        request,
         timeout: undefined,
         callback: (response) => {
             if (response instanceof AskTimeoutError) {
@@ -29,15 +34,11 @@ const askSync = (options) => {
                 msgRef = { msg: response };
             }
         },
-        props: {
-            mailbox: {
-                scheduler: PriorityScheduler.create("sync"),
-            },
-        },
+        props: { profile },
     });
     if (error)
         throw error;
-    assertsSynchronousResponse(options.to, msgRef);
+    assertsSynchronousResponse(to, msgRef);
     return msgRef.msg;
 };
 const assertsSynchronousResponse = (to, response) => {
@@ -46,20 +47,12 @@ const assertsSynchronousResponse = (to, response) => {
     }
 };
 const assertsActorSupportsSync = (to) => {
-    if (!(to instanceof LocalActorRef)) {
+    if (!isActorLookup(to)) {
         throw new UnsupportedSyncOperationError(`Synchronous ask operations are only supported for local actors. Actor '${to.path}' is not a local actor reference.`, to);
     }
-    if (to._mailbox.schedulerType !== SchedulerType.Sync) {
+    if (to._getActor().dispatcher.scheduler !== sync) {
         throw new UnsupportedSyncOperationError(`Actor '${to.path}' does not support synchronous processing. Ensure the actor's mailbox is configured with a synchronous scheduler.`, to);
     }
 };
-const assertsActorIsIdle = (to) => {
-    if (to._mailbox.ongoingProcess !== undefined) {
-        throw new ReentryError(`Synchronous ask cannot be performed because actor '${to.path}' is currently processing another message (reentrancy).`, to);
-    }
-    if (to._mailbox.state !== "connected") {
-        throw new DisconnectedError(`Synchronous ask cannot be performed because actor '${to.path}' is not in a connected state.`, to);
-    }
-};
 
 export { askSync };

package/dist/ask-with-callback.js

@@ -1,5 +1,5 @@
 import { receiveMessage, stopped } from '@actor-system/behaviors';
-import { $system, signal } from '@actor-system/core';
+import { isSystemLookup, signal } from '@actor-system/core';
 import { generateMonotonicULID } from './__bundle__/shared/dist/monotonicULID.js';
 import { AskTimeoutError } from './errors.js';
 
@@ -21,7 +21,9 @@ const _askWithCallback = (options) => {
             replyTo.tell(new AskTimeoutError(`Ask to '${to.path}' timed out after ${timeout}ms`, to, timeout));
         }, Math.max(0, timeout));
     }
-    const replyTo = to[$system].systemActorOf(receiveMessage((msg) => {
+    if (!isSystemLookup(to))
+        throw new Error(`Ask target ${to.path} must be a system bound actor`);
+    const replyTo = to._getSystem().systemActorOf(receiveMessage((msg) => {
         if (!(msg instanceof AskTimeoutError) && !done) {
             clearTimeout(timer);
             callback(msg);

package/dist/ask.d.ts

@@ -1,12 +1,6 @@
 import { ActorRef } from '@actor-system/core';
 import { CreateRequest } from './ask-with-callback.js';
 
-interface AskOptions<Req, Res> {
-    timeout?: number;
-    to: ActorRef<Req>;
-    request: CreateRequest<Req, Res>;
-}
-declare const ask: <const Req, Res>(options: AskOptions<Req, Res>) => Promise<Res>;
+declare const ask: <const Req, Res>(to: ActorRef<Req>, request: CreateRequest<Req, Res>, timeout?: number) => Promise<Res>;
 
 export { ask };
-export type { AskOptions };

package/dist/ask.internal.d.ts

@@ -1,12 +1,6 @@
 import { ActorRef } from '@actor-system/core/internal';
 import { CreateRequest } from './ask-with-callback.internal.js';
 
-interface AskOptions<Req, Res> {
-    timeout?: number;
-    to: ActorRef<Req>;
-    request: CreateRequest<Req, Res>;
-}
-declare const ask: <const Req, Res>(options: AskOptions<Req, Res>) => Promise<Res>;
+declare const ask: <const Req, Res>(to: ActorRef<Req>, request: CreateRequest<Req, Res>, timeout?: number) => Promise<Res>;
 
 export { ask };
-export type { AskOptions };

package/dist/ask.js

@@ -1,9 +1,10 @@
 import { _askWithCallback } from './ask-with-callback.js';
 import { AskTimeoutError } from './errors.js';
 
-const ask = (options) => new Promise((resolve, reject) => _askWithCallback({
-    timeout: 1000,
-    ...options,
+const ask = (to, request, timeout = 1000) => new Promise((resolve, reject) => _askWithCallback({
+    timeout,
+    to,
+    request,
     callback: (response) => {
         if (response instanceof AskTimeoutError) {
             reject(response);

package/dist/errors.d.ts

@@ -4,7 +4,6 @@ import { Letter } from '@actor-system/mail';
 declare const $timeoutError = "@@ask.timeout-error";
 declare const $unsupportedSyncOperationError = "@@ask.unsupported-sync-operation-error";
 declare const $noSynchronousResponseError = "@@ask.no-synchronous-response-error";
-declare const $reentryError = "@@ask.reentry-error";
 declare const $disconnectedError = "@@ask.disconnected-error";
 declare class AskTimeoutError extends Error implements Letter<typeof $timeoutError> {
     readonly label: typeof $timeoutError;
@@ -35,12 +34,6 @@ declare class NoSynchronousResponseError extends Error implements Letter<typeof
     readonly to: ActorRef;
     constructor(message: string, to: ActorRef, from?: ActorRef);
 }
-declare class ReentryError extends Error implements Letter<typeof $reentryError> {
-    readonly label: typeof $reentryError;
-    readonly from?: ActorRef;
-    readonly to: ActorRef;
-    constructor(message: string, to: ActorRef, from?: ActorRef);
-}
 declare class DisconnectedError extends Error implements Letter<typeof $disconnectedError> {
     readonly label: typeof $disconnectedError;
     readonly from?: ActorRef;
@@ -48,4 +41,4 @@ declare class DisconnectedError extends Error implements Letter<typeof $disconne
     constructor(message: string, to: ActorRef, from?: ActorRef);
 }
 
-export { $disconnectedError, $noSynchronousResponseError, $reentryError, $timeoutError, $unsupportedSyncOperationError, AskTimeoutError, DisconnectedError, NoSynchronousResponseError, ReentryError, UnsupportedSyncOperationError };
+export { $disconnectedError, $noSynchronousResponseError, $timeoutError, $unsupportedSyncOperationError, AskTimeoutError, DisconnectedError, NoSynchronousResponseError, UnsupportedSyncOperationError };

package/dist/errors.internal.d.ts

@@ -4,7 +4,6 @@ import { Letter } from '@actor-system/mail/internal';
 declare const $timeoutError = "@@ask.timeout-error";
 declare const $unsupportedSyncOperationError = "@@ask.unsupported-sync-operation-error";
 declare const $noSynchronousResponseError = "@@ask.no-synchronous-response-error";
-declare const $reentryError = "@@ask.reentry-error";
 declare const $disconnectedError = "@@ask.disconnected-error";
 declare class AskTimeoutError extends Error implements Letter<typeof $timeoutError> {
     readonly label: typeof $timeoutError;
@@ -35,12 +34,6 @@ declare class NoSynchronousResponseError extends Error implements Letter<typeof
     readonly to: ActorRef;
     constructor(message: string, to: ActorRef, from?: ActorRef);
 }
-declare class ReentryError extends Error implements Letter<typeof $reentryError> {
-    readonly label: typeof $reentryError;
-    readonly from?: ActorRef;
-    readonly to: ActorRef;
-    constructor(message: string, to: ActorRef, from?: ActorRef);
-}
 declare class DisconnectedError extends Error implements Letter<typeof $disconnectedError> {
     readonly label: typeof $disconnectedError;
     readonly from?: ActorRef;
@@ -48,4 +41,4 @@ declare class DisconnectedError extends Error implements Letter<typeof $disconne
     constructor(message: string, to: ActorRef, from?: ActorRef);
 }
 
-export { $disconnectedError, $noSynchronousResponseError, $reentryError, $timeoutError, $unsupportedSyncOperationError, AskTimeoutError, DisconnectedError, NoSynchronousResponseError, ReentryError, UnsupportedSyncOperationError };
+export { $disconnectedError, $noSynchronousResponseError, $timeoutError, $unsupportedSyncOperationError, AskTimeoutError, DisconnectedError, NoSynchronousResponseError, UnsupportedSyncOperationError };

package/dist/errors.js

@@ -1,7 +1,6 @@
 const $timeoutError = "@@ask.timeout-error";
 const $unsupportedSyncOperationError = "@@ask.unsupported-sync-operation-error";
 const $noSynchronousResponseError = "@@ask.no-synchronous-response-error";
-const $reentryError = "@@ask.reentry-error";
 const $disconnectedError = "@@ask.disconnected-error";
 class AskTimeoutError extends Error {
     label = $timeoutError;
@@ -48,17 +47,6 @@ class NoSynchronousResponseError extends Error {
         this.to = to;
     }
 }
-class ReentryError extends Error {
-    label = $reentryError;
-    from;
-    to;
-    constructor(message, to, from) {
-        super(message);
-        this.name = "ReentryError";
-        this.from = from;
-        this.to = to;
-    }
-}
 class DisconnectedError extends Error {
     label = $disconnectedError;
     from;
@@ -71,4 +59,4 @@ class DisconnectedError extends Error {
     }
 }
 
-export { $disconnectedError, $noSynchronousResponseError, $reentryError, $timeoutError, $unsupportedSyncOperationError, AskTimeoutError, DisconnectedError, NoSynchronousResponseError, ReentryError, UnsupportedSyncOperationError };
+export { $disconnectedError, $noSynchronousResponseError, $timeoutError, $unsupportedSyncOperationError, AskTimeoutError, DisconnectedError, NoSynchronousResponseError, UnsupportedSyncOperationError };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { AskSyncOptions, askSync } from './ask-sync.js';
-export { AskOptions, ask } from './ask.js';
-export { $disconnectedError, $noSynchronousResponseError, $reentryError, $timeoutError, $unsupportedSyncOperationError, AskTimeoutError, DisconnectedError, NoSynchronousResponseError, ReentryError, UnsupportedSyncOperationError } from './errors.js';
+export { askSync } from './ask-sync.js';
+export { ask } from './ask.js';
+export { $disconnectedError, $noSynchronousResponseError, $timeoutError, $unsupportedSyncOperationError, AskTimeoutError, DisconnectedError, NoSynchronousResponseError, UnsupportedSyncOperationError } from './errors.js';
 export { Ask, MapResponse, WithAskOptions, withAsk } from './use-ask.js';

package/dist/index.internal.d.ts

@@ -1,4 +1,4 @@
-export { AskSyncOptions, askSync } from './ask-sync.internal.js';
-export { AskOptions, ask } from './ask.internal.js';
-export { $disconnectedError, $noSynchronousResponseError, $reentryError, $timeoutError, $unsupportedSyncOperationError, AskTimeoutError, DisconnectedError, NoSynchronousResponseError, ReentryError, UnsupportedSyncOperationError } from './errors.internal.js';
+export { askSync } from './ask-sync.internal.js';
+export { ask } from './ask.internal.js';
+export { $disconnectedError, $noSynchronousResponseError, $timeoutError, $unsupportedSyncOperationError, AskTimeoutError, DisconnectedError, NoSynchronousResponseError, UnsupportedSyncOperationError } from './errors.internal.js';
 export { Ask, MapResponse, WithAskOptions, withAsk } from './use-ask.internal.js';

package/dist/index.js

@@ -1,4 +1,4 @@
 export { askSync } from './ask-sync.js';
 export { ask } from './ask.js';
-export { $disconnectedError, $noSynchronousResponseError, $reentryError, $timeoutError, $unsupportedSyncOperationError, AskTimeoutError, DisconnectedError, NoSynchronousResponseError, ReentryError, UnsupportedSyncOperationError } from './errors.js';
+export { $disconnectedError, $noSynchronousResponseError, $timeoutError, $unsupportedSyncOperationError, AskTimeoutError, DisconnectedError, NoSynchronousResponseError, UnsupportedSyncOperationError } from './errors.js';
 export { withAsk } from './use-ask.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@actor-system/ask",
-  "version": "0.0.18",
+  "version": "0.1.0",
   "type": "module",
   "scripts": {
     "type-check": "tsc -b src",
@@ -34,12 +34,13 @@
     "@actor-system/shared"
   ],
   "dependencies": {
-    "@actor-system/behaviors": "0.0.18",
-    "@actor-system/core": "0.1.2",
-    "@actor-system/mail": "0.0.3"
+    "@actor-system/behaviors": "0.1.0",
+    "@actor-system/core": "0.2.0",
+    "@actor-system/mail": "0.0.3",
+    "@actor-system/scheduler": "0.1.0"
   },
   "devDependencies": {
-    "@actor-system/testing": "0.0.2",
+    "@actor-system/testing": "0.1.0",
     "@actor-system/shared": "0.0.3",
     "config": "^1.0.0"
   }