@maaxyz/maa-node 4.4.0-beta.1 → 4.4.0

package/dist/controller.d.ts

@@ -1,5 +1,7 @@
 import { Job, JobSource } from './job';
 import maa, { ImageData } from './maa';
+import { ChainNotifyType } from './types';
+import { chain_notify_impl } from './utils';
 declare class ImageJob extends Job<maa.CtrlId, JobSource<maa.CtrlId>> {
     #private;
     constructor(ctrl: ControllerBase, source: JobSource<maa.CtrlId>, id: maa.CtrlId);
@@ -13,23 +15,9 @@ declare class ImageJob extends Job<maa.CtrlId, JobSource<maa.CtrlId>> {
         get: () => Promise<ArrayBuffer | null>;
     };
 }
-export type ControllerNotify = ({
-    adb: string;
-    address: string;
-} & ({
-    msg: 'UUIDGot';
-    uuid: string;
-} | {
-    msg: 'UUIDGetFailed';
-} | {
-    msg: 'ConnectSuccess';
-} | {
-    msg: 'ConnectFailed';
-    why: 'ConnectFailed' | 'UUIDGetFailed';
-} | {
-    msg: 'ScreencapInited' | 'ScreencapInitFailed' | 'TouchinputInited' | 'TouchinputInitFailed';
-})) | {
-    msg: 'Action.Started' | 'Action.Completed' | 'Action.Failed';
+export type ControllerNotify = {
+    msg: 'Action.Starting' | 'Action.Succeeded' | 'Action.Failed';
+    action: 'connect' | 'click' | 'swipe' | 'touch_down' | 'touch_move' | 'touch_up' | 'press_key' | 'input_text' | 'screencap' | 'start_app' | 'stop_app';
     ctrl_id: maa.CtrlId;
     uuid: string;
 };
@@ -37,7 +25,8 @@ export declare class ControllerBase {
     #private;
     handle: maa.ControllerHandle;
     notify(message: string, details_json: string): maa.MaybePromise<void>;
-    set parsed_notify(cb: (msg: ControllerNotify) => maa.MaybePromise<void>);
+    chain_notify: typeof chain_notify_impl;
+    chain_parsed_notify(cb: (msg: ControllerNotify) => maa.MaybePromise<void>, order?: ChainNotifyType): void;
     constructor(handle: maa.ControllerHandle);
     destroy(): void;
     set screenshot_target_long_side(value: number);

package/dist/index-client.js

@@ -150,6 +150,42 @@ var Job = class {
 
 // src/controller.ts
 var import_maa = __toESM(require_maa());
+
+// src/utils.ts
+function chain_notify_impl(cb, order = "after") {
+  const old = this.notify;
+  switch (order) {
+    case "before":
+      this.notify = async (msg, details) => {
+        await cb(msg, details);
+        await old.call(this, msg, details);
+      };
+      break;
+    case "after":
+      this.notify = async (msg, details) => {
+        await old.call(this, msg, details);
+        await cb(msg, details);
+      };
+      break;
+    case "before-no-wait":
+      this.notify = async (msg, details) => {
+        cb(msg, details);
+        await old.call(this, msg, details);
+      };
+      break;
+    case "after-no-wait":
+      this.notify = async (msg, details) => {
+        await old.call(this, msg, details);
+        cb(msg, details);
+      };
+      break;
+    case "replace":
+      this.notify = cb;
+      break;
+  }
+}
+
+// src/controller.ts
 var ImageJob = class extends Job {
   #ctrl;
   constructor(ctrl, source, id) {
@@ -181,13 +217,14 @@ var ControllerBase = class {
   #source;
   notify(message, details_json) {
   }
-  set parsed_notify(cb) {
-    this.notify = (msg, details) => {
+  chain_notify = chain_notify_impl;
+  chain_parsed_notify(cb, order = "after") {
+    this.chain_notify((msg, details) => {
       return cb({
         msg: msg.replace(/^Controller\./, ""),
         ...JSON.parse(details)
       });
-    };
+    }, order);
   }
   constructor(handle) {
     this.handle = handle;
@@ -433,13 +470,14 @@ var TaskerBase = class {
   #source;
   notify(message, details_json) {
   }
-  set parsed_notify(cb) {
-    this.notify = (msg, details) => {
+  chain_notify = chain_notify_impl;
+  chain_parsed_notify(cb, order = "after") {
+    this.chain_notify((msg, details) => {
       return cb({
         msg: msg.replace(/^(?:Tasker|Node)?\./, ""),
         ...JSON.parse(details)
       });
-    };
+    }, order);
   }
   constructor(handle) {
     this.handle = handle;
@@ -636,13 +674,14 @@ var ResourceBase = class {
   #source;
   notify(message, details_json) {
   }
-  set parsed_notify(cb) {
-    this.notify = (msg, details) => {
+  chain_notify = chain_notify_impl;
+  chain_parsed_notify(cb, order = "after") {
+    this.chain_notify((msg, details) => {
       return cb({
         msg: msg.replace(/^Resource\./, ""),
         ...JSON.parse(details)
       });
-    };
+    }, order);
   }
   constructor(handle) {
     this.handle = handle;

package/dist/index-server.js

@@ -150,6 +150,42 @@ var Job = class {
 
 // src/controller.ts
 var import_maa = __toESM(require_maa());
+
+// src/utils.ts
+function chain_notify_impl(cb, order = "after") {
+  const old = this.notify;
+  switch (order) {
+    case "before":
+      this.notify = async (msg, details) => {
+        await cb(msg, details);
+        await old.call(this, msg, details);
+      };
+      break;
+    case "after":
+      this.notify = async (msg, details) => {
+        await old.call(this, msg, details);
+        await cb(msg, details);
+      };
+      break;
+    case "before-no-wait":
+      this.notify = async (msg, details) => {
+        cb(msg, details);
+        await old.call(this, msg, details);
+      };
+      break;
+    case "after-no-wait":
+      this.notify = async (msg, details) => {
+        await old.call(this, msg, details);
+        cb(msg, details);
+      };
+      break;
+    case "replace":
+      this.notify = cb;
+      break;
+  }
+}
+
+// src/controller.ts
 var ImageJob = class extends Job {
   #ctrl;
   constructor(ctrl, source, id) {
@@ -181,13 +217,14 @@ var ControllerBase = class {
   #source;
   notify(message, details_json) {
   }
-  set parsed_notify(cb) {
-    this.notify = (msg, details) => {
+  chain_notify = chain_notify_impl;
+  chain_parsed_notify(cb, order = "after") {
+    this.chain_notify((msg, details) => {
       return cb({
         msg: msg.replace(/^Controller\./, ""),
         ...JSON.parse(details)
       });
-    };
+    }, order);
   }
   constructor(handle) {
     this.handle = handle;
@@ -433,13 +470,14 @@ var TaskerBase = class {
   #source;
   notify(message, details_json) {
   }
-  set parsed_notify(cb) {
-    this.notify = (msg, details) => {
+  chain_notify = chain_notify_impl;
+  chain_parsed_notify(cb, order = "after") {
+    this.chain_notify((msg, details) => {
       return cb({
         msg: msg.replace(/^(?:Tasker|Node)?\./, ""),
         ...JSON.parse(details)
       });
-    };
+    }, order);
   }
   constructor(handle) {
     this.handle = handle;
@@ -636,13 +674,14 @@ var ResourceBase = class {
   #source;
   notify(message, details_json) {
   }
-  set parsed_notify(cb) {
-    this.notify = (msg, details) => {
+  chain_notify = chain_notify_impl;
+  chain_parsed_notify(cb, order = "after") {
+    this.chain_notify((msg, details) => {
       return cb({
         msg: msg.replace(/^Resource\./, ""),
         ...JSON.parse(details)
       });
-    };
+    }, order);
   }
   constructor(handle) {
     this.handle = handle;

package/dist/pipeline.d.ts

@@ -1,8 +1,17 @@
 import type { FlatRect } from './maa';
 type NodeName = string;
-type OutputRemove<T, Output> = Output extends true ? never : T;
-type MaybeArray<T, Output> = T[] | OutputRemove<T, Output>;
+export type ModeFragment = 0;
+export type ModeStrict = 1;
+export type ModeDump = 2;
+type RemoveIfDump<T, Mode> = Mode extends ModeDump ? never : T;
+type MaybeArray<T, Mode> = T[] | RemoveIfDump<T, Mode>;
 type FixedArray<T, K extends number, A extends T[] = []> = A['length'] extends K ? A : FixedArray<T, K, [...A, T]>;
+type RequiredIfStrict<T, Keys, Mode> = Mode extends ModeStrict ? RequiredKeys<T, Keys> : T;
+type RequiredKeys<T, Keys> = {
+    [key in keyof T & Keys]: NonNullable<T[key]>;
+} & {
+    [key in Exclude<keyof T, Keys>]: T[key];
+};
 type OrderByMap = {
     TemplateMatch: 'Horizontal' | 'Vertical' | 'Score' | 'Random';
     FeatureMatch: 'Horizontal' | 'Vertical' | 'Score' | 'Area' | 'Random';
@@ -12,96 +21,94 @@ type OrderByMap = {
     NeuralNetworkDetect: 'Horizontal' | 'Vertical' | 'Score' | 'Area' | 'Random';
 };
 export type RecognitionDirectHit = {};
-export type RecognitionTemplateMatch<Output> = {
+export type RecognitionTemplateMatch<Mode> = RequiredIfStrict<{
     roi?: FlatRect | NodeName;
     roi_offset?: FlatRect;
-    template?: MaybeArray<string, Output>;
-    template_?: MaybeArray<string, Output>;
-    threshold?: MaybeArray<number, Output>;
+    template?: MaybeArray<string, Mode>;
+    threshold?: MaybeArray<number, Mode>;
     order_by?: OrderByMap['TemplateMatch'];
     index?: number;
     method?: 1 | 3 | 5;
     green_mask?: boolean;
-};
-export type RecognitionFeatureMatch<Output> = {
+}, 'template', Mode>;
+export type RecognitionFeatureMatch<Mode> = RequiredIfStrict<{
     roi?: FlatRect | NodeName;
     roi_offset?: FlatRect;
-    template?: MaybeArray<string, Output>;
-    template_?: MaybeArray<string, Output>;
+    template?: MaybeArray<string, Mode>;
     count?: number;
     order_by?: OrderByMap['FeatureMatch'];
     index?: number;
     green_mask?: boolean;
     detector?: 'SIFT' | 'KAZE' | 'AKAZE' | 'BRISK' | 'ORB';
     ratio?: number;
-};
-export type RecognitionColorMatch<Output> = {
+}, 'template', Mode>;
+export type RecognitionColorMatch<Mode> = {
     roi?: FlatRect | NodeName;
     roi_offset?: FlatRect;
-} & ({
+} & RequiredIfStrict<{
     method?: 4 | 40;
-    lower?: MaybeArray<FixedArray<number, 3>, Output>;
-    upper?: MaybeArray<FixedArray<number, 3>, Output>;
+    lower?: MaybeArray<FixedArray<number, 3>, Mode>;
+    upper?: MaybeArray<FixedArray<number, 3>, Mode>;
 } | {
     method: 6;
-    lower?: MaybeArray<FixedArray<number, 1>, Output>;
-    upper?: MaybeArray<FixedArray<number, 1>, Output>;
-}) & {
+    lower?: MaybeArray<FixedArray<number, 1>, Mode>;
+    upper?: MaybeArray<FixedArray<number, 1>, Mode>;
+}, 'lower' | 'upper', Mode> & {
     count?: number;
     order_by?: OrderByMap['ColorMatch'];
     index?: number;
     connected?: boolean;
 };
-export type RecognitionOCR<Output> = {
+export type RecognitionOCR<Mode> = RequiredIfStrict<{
     roi?: FlatRect | NodeName;
     roi_offset?: FlatRect;
-    expected?: MaybeArray<string, Output>;
-    threshold?: MaybeArray<number, Output>;
-    replace?: MaybeArray<FixedArray<string, 2>, Output>;
+    expected?: MaybeArray<string, Mode>;
+    threshold?: MaybeArray<number, Mode>;
+    replace?: MaybeArray<FixedArray<string, 2>, Mode>;
     order_by?: OrderByMap['OCR'];
     index?: number;
     only_rec?: boolean;
     model?: string;
-};
-export type RecognitionNeuralNetworkClassify<Output> = {
+}, 'expected', Mode>;
+export type RecognitionNeuralNetworkClassify<Mode> = RequiredIfStrict<{
     roi?: FlatRect | NodeName;
     roi_offset?: FlatRect;
     labels?: string[];
     model?: string;
-    expected?: MaybeArray<number, Output>;
+    expected?: MaybeArray<number, Mode>;
     order_by?: OrderByMap['NeuralNetworkClassify'];
     index?: number;
-};
-export type RecognitionNeuralNetworkDetect<Output> = {
+}, 'model', Mode>;
+export type RecognitionNeuralNetworkDetect<Mode> = RequiredIfStrict<{
     roi?: FlatRect | NodeName;
     roi_offset?: FlatRect;
     labels?: string[];
     model?: string;
-    expected?: MaybeArray<number, Output>;
+    expected?: MaybeArray<number, Mode>;
     threshold?: number;
     order_by?: OrderByMap['NeuralNetworkDetect'];
     index?: number;
-};
-export type RecognitionCustom = {
+}, 'model', Mode>;
+export type RecognitionCustom<Mode> = RequiredIfStrict<{
     roi?: FlatRect | NodeName;
     roi_offset?: FlatRect;
     custom_recognition?: string;
     custom_recognition_param?: unknown;
-};
-type MixReco<Type extends string, Param, Output> = {
+}, 'custom_recognition', Mode>;
+type MixReco<Type extends string, Param, Mode> = {
     recognition: {
         type: Type;
         param?: Param;
     };
-} | OutputRemove<{
+} | RemoveIfDump<{
     recognition: Type;
-} & Param, Output>;
-export type Recognition<Output> = OutputRemove<{
+} & Param, Mode>;
+export type Recognition<Mode> = RemoveIfDump<{
     recognition?: {
         type?: never;
         param?: never;
     };
-}, Output> | MixReco<'DirectHit', RecognitionDirectHit, Output> | MixReco<'TemplateMatch', RecognitionTemplateMatch<Output>, Output> | MixReco<'FeatureMatch', RecognitionFeatureMatch<Output>, Output> | MixReco<'ColorMatch', RecognitionColorMatch<Output>, Output> | MixReco<'OCR', RecognitionOCR<Output>, Output> | MixReco<'NeuralNetworkClassify', RecognitionNeuralNetworkClassify<Output>, Output> | MixReco<'NeuralNetworkDetect', RecognitionNeuralNetworkDetect<Output>, Output> | MixReco<'Custom', RecognitionCustom, Output>;
+}, Mode> | MixReco<'DirectHit', RecognitionDirectHit, Mode> | MixReco<'TemplateMatch', RecognitionTemplateMatch<Mode>, Mode> | MixReco<'FeatureMatch', RecognitionFeatureMatch<Mode>, Mode> | MixReco<'ColorMatch', RecognitionColorMatch<Mode>, Mode> | MixReco<'OCR', RecognitionOCR<Mode>, Mode> | MixReco<'NeuralNetworkClassify', RecognitionNeuralNetworkClassify<Mode>, Mode> | MixReco<'NeuralNetworkDetect', RecognitionNeuralNetworkDetect<Mode>, Mode> | MixReco<'Custom', RecognitionCustom<Mode>, Mode>;
 export type ActionDoNothing = {};
 export type ActionClick = {
     target?: true | NodeName | FlatRect;
@@ -119,7 +126,7 @@ export type ActionSwipe = {
     end_offset?: FlatRect;
     duration?: number;
 };
-export type ActionMultiSwipe = {
+export type ActionMultiSwipe<Mode> = RequiredIfStrict<{
     swipes?: {
         starting?: number;
         begin?: true | NodeName | FlatRect;
@@ -128,45 +135,45 @@ export type ActionMultiSwipe = {
         end_offset?: FlatRect;
         duration?: number;
     }[];
-};
-export type ActionKey<Output> = {
-    key?: MaybeArray<number, Output>;
-};
-export type ActionInputText = {
+}, 'swipes', Mode>;
+export type ActionKey<Mode> = RequiredIfStrict<{
+    key?: MaybeArray<number, Mode>;
+}, 'key', Mode>;
+export type ActionInputText<Mode> = RequiredIfStrict<{
     input_text?: string;
-};
-export type ActionStartApp = {
+}, 'input_text', Mode>;
+export type ActionStartApp<Mode> = RequiredIfStrict<{
     package?: string;
-};
-export type ActionStopApp = {
+}, 'package', Mode>;
+export type ActionStopApp<Mode> = RequiredIfStrict<{
     package?: string;
-};
+}, 'package', Mode>;
 export type ActionStopTask = {};
-export type ActionCommand = {
+export type ActionCommand<Mode> = RequiredIfStrict<{
     exec?: string;
     args?: string[];
     detach?: boolean;
-};
-export type ActionCustom = {
+}, 'exec', Mode>;
+export type ActionCustom<Mode> = RequiredIfStrict<{
     target?: true | NodeName | FlatRect;
     target_offset?: FlatRect;
     custom_action?: string;
     custom_action_param?: unknown;
-};
-type MixAct<Type extends string, Param, Output> = OutputRemove<{
+}, 'custom_action', Mode>;
+type MixAct<Type extends string, Param, Mode> = RemoveIfDump<{
     action: Type;
-} & Param, Output> | {
+} & Param, Mode> | {
     action: {
         type: Type;
         param?: Param;
     };
 };
-export type Action<Output> = OutputRemove<{
+export type Action<Mode> = RemoveIfDump<{
     action?: {
         type?: never;
         param?: never;
     };
-}, Output> | MixAct<'DoNothing', ActionDoNothing, Output> | MixAct<'Click', ActionClick, Output> | MixAct<'LongPress', ActionLongPress, Output> | MixAct<'Swipe', ActionSwipe, Output> | MixAct<'MultiSwipe', ActionMultiSwipe, Output> | MixAct<'Key', ActionKey<Output>, Output> | MixAct<'InputText', ActionInputText, Output> | MixAct<'StartApp', ActionStartApp, Output> | MixAct<'StopApp', ActionStopApp, Output> | MixAct<'StopTask', ActionStopTask, Output> | MixAct<'Command', ActionCommand, Output> | MixAct<'Custom', ActionCustom, Output>;
+}, Mode> | MixAct<'DoNothing', ActionDoNothing, Mode> | MixAct<'Click', ActionClick, Mode> | MixAct<'LongPress', ActionLongPress, Mode> | MixAct<'Swipe', ActionSwipe, Mode> | MixAct<'MultiSwipe', ActionMultiSwipe<Mode>, Mode> | MixAct<'Key', ActionKey<Mode>, Mode> | MixAct<'InputText', ActionInputText<Mode>, Mode> | MixAct<'StartApp', ActionStartApp<Mode>, Mode> | MixAct<'StopApp', ActionStopApp<Mode>, Mode> | MixAct<'StopTask', ActionStopTask, Mode> | MixAct<'Command', ActionCommand<Mode>, Mode> | MixAct<'Custom', ActionCustom<Mode>, Mode>;
 export type WaitFreeze = {
     time?: number;
     target?: true | NodeName | FlatRect;
@@ -176,24 +183,25 @@ export type WaitFreeze = {
     rate_limit?: number;
     timeout?: number;
 };
-export type General<Output> = {
-    next?: MaybeArray<NodeName, Output>;
-    interrupt?: MaybeArray<NodeName, Output>;
+export type General<Mode> = {
+    next?: MaybeArray<NodeName, Mode>;
+    interrupt?: MaybeArray<NodeName, Mode>;
     is_sub?: boolean;
     rate_limit?: number;
     timeout?: number;
-    on_error?: MaybeArray<string, Output>;
+    on_error?: MaybeArray<string, Mode>;
     inverse?: boolean;
     enabled?: boolean;
     pre_delay?: boolean;
     post_delay?: boolean;
-    pre_wait_freezes?: OutputRemove<number, Output> | WaitFreeze;
-    post_wait_freezes?: OutputRemove<number, Output> | WaitFreeze;
+    pre_wait_freezes?: RemoveIfDump<number, Mode> | WaitFreeze;
+    post_wait_freezes?: RemoveIfDump<number, Mode> | WaitFreeze;
     focus?: unknown;
 };
-export type Task = Recognition<false> & Action<false> & General<false>;
+export type Task = Recognition<ModeFragment> & Action<ModeFragment> & General<ModeFragment>;
+export type StrictTask = Recognition<ModeStrict> & Action<ModeStrict> & General<ModeStrict>;
 type RecursiveRequired<T> = T extends Record<string, unknown> ? {
-    [key in keyof T]-?: RecursiveRequired<T[key]>;
+    [key in keyof T]: NonNullable<RecursiveRequired<T[key]>>;
 } : T;
-export type DumpTask = RecursiveRequired<Recognition<true> & Action<true> & General<true>>;
+export type DumpTask = RecursiveRequired<Recognition<ModeDump> & Action<ModeDump> & General<ModeDump>>;
 export {};

package/dist/resource.d.ts

@@ -1,21 +1,20 @@
 import { Job, JobSource } from './job';
 import maa from './maa';
 import { DumpTask } from './pipeline';
-import { CustomActionCallback, CustomRecognizerCallback } from './types';
+import { ChainNotifyType, CustomActionCallback, CustomRecognizerCallback } from './types';
+import { chain_notify_impl } from './utils';
 export type ResourceNotify = {
+    msg: 'Loading.Starting' | 'Loading.Succeeded' | 'Loading.Failed';
     res_id: maa.ResId;
     path: string;
-} & ({
-    msg: 'StartLoading';
-} | {
-    msg: 'LoadingCompleted' | 'LoadingFailed';
     hash: string;
-});
+};
 export declare class ResourceBase {
     #private;
     handle: maa.ResourceHandle;
     notify(message: string, details_json: string): maa.MaybePromise<void>;
-    set parsed_notify(cb: (msg: ResourceNotify) => maa.MaybePromise<void>);
+    chain_notify: typeof chain_notify_impl;
+    chain_parsed_notify(cb: (msg: ResourceNotify) => maa.MaybePromise<void>, order?: ChainNotifyType): void;
     constructor(handle: maa.ResourceHandle);
     destroy(): void;
     set inference_device(id: keyof typeof maa.InferenceDevice | number);

package/dist/tasker.d.ts

@@ -2,6 +2,8 @@ import { ControllerBase } from './controller';
 import { Job, JobSource } from './job';
 import maa from './maa';
 import { ResourceBase } from './resource';
+import { ChainNotifyType } from './types';
+import { chain_notify_impl } from './utils';
 type TaskDetail = ReturnType<TaskerBase['task_detail']>;
 type RecoDetailEntry = {
     box: maa.FlatRect;
@@ -47,36 +49,36 @@ declare class TaskJob extends Job<maa.TaskId, JobSource<maa.TaskId>> {
     };
 }
 export type TaskerNotify = {
+    msg: 'Task.Started' | 'Task.Completed' | 'Task.Failed';
     task_id: maa.TaskId;
     entry: string;
-    hash: string;
     uuid: string;
-} & ({
-    msg: 'Task.Started' | 'Task.Completed' | 'Task.Failed';
+    hash: string;
 } | {
     msg: 'NextList.Starting' | 'NextList.Succeeded' | 'NextList.Failed';
-    task_id: number;
+    task_id: maa.TaskId;
     name: string;
     list: string[];
     focus: unknown;
 } | {
     msg: 'Recognition.Starting' | 'Recognition.Succeeded' | 'Recognition.Failed';
-    task_id: number;
-    reco_id: number;
+    task_id: maa.TaskId;
+    reco_id: maa.RecoId;
     name: string;
     focus: unknown;
 } | {
     msg: 'Action.Starting' | 'Action.Succeeded' | 'Action.Failed';
-    task_id: number;
-    node_id: number;
+    task_id: maa.TaskId;
+    node_id: maa.NodeId;
     name: string;
     focus: unknown;
-});
+};
 export declare class TaskerBase {
     #private;
     handle: maa.TaskerHandle;
     notify(message: string, details_json: string): maa.MaybePromise<void>;
-    set parsed_notify(cb: (msg: TaskerNotify) => maa.MaybePromise<void>);
+    chain_notify: typeof chain_notify_impl;
+    chain_parsed_notify(cb: (msg: TaskerNotify) => maa.MaybePromise<void>, order?: ChainNotifyType): void;
     constructor(handle: maa.TaskerHandle);
     destroy(): void;
     bind(slave: ControllerBase | ResourceBase): void;

package/dist/types.d.ts

@@ -24,4 +24,5 @@ export type CustomRecognizerCallback = CustomCallback<CustomRecognizerSelf, [
     out_detail: string
 ] | null>;
 export type CustomActionCallback = CustomCallback<CustomActionSelf, boolean>;
+export type ChainNotifyType = 'before' | 'after' | 'before-no-wait' | 'after-no-wait' | 'replace';
 export {};

package/dist/utils.d.ts

@@ -0,0 +1,5 @@
+import maa from './maa';
+import { ChainNotifyType } from './types';
+export declare function chain_notify_impl(this: {
+    notify: maa.NotificationCallback;
+}, cb: maa.NotificationCallback, order?: ChainNotifyType): void;

package/package.json

@@ -25,13 +25,13 @@
         "prettier": "^3.5.2",
         "typescript": "^5.8.2"
     },
-    "version": "4.4.0-beta.1",
+    "version": "4.4.0",
     "optionalDependencies": {
-        "@maaxyz/maa-node-darwin-arm64": "4.4.0-beta.1",
-        "@maaxyz/maa-node-darwin-x64": "4.4.0-beta.1",
-        "@maaxyz/maa-node-linux-arm64": "4.4.0-beta.1",
-        "@maaxyz/maa-node-linux-x64": "4.4.0-beta.1",
-        "@maaxyz/maa-node-win32-arm64": "4.4.0-beta.1",
-        "@maaxyz/maa-node-win32-x64": "4.4.0-beta.1"
+        "@maaxyz/maa-node-darwin-arm64": "4.4.0",
+        "@maaxyz/maa-node-darwin-x64": "4.4.0",
+        "@maaxyz/maa-node-linux-arm64": "4.4.0",
+        "@maaxyz/maa-node-linux-x64": "4.4.0",
+        "@maaxyz/maa-node-win32-arm64": "4.4.0",
+        "@maaxyz/maa-node-win32-x64": "4.4.0"
     }
 }