@akashic/headless-driver 1.11.36 → 2.0.0

package/README.md

@@ -1 +1,31 @@
+<p align="center">
+<img src="https://github.com/akashic-games/headless-driver/blob/master/img/akashic.png"/>
+</p>
+
 # headless-driver
+
+## インストール
+Node.jsが必要です。次のコマンドでインストールできます。
+
+```sh
+npm i
+```
+
+## ビルド
+
+```sh
+npm run build
+```
+
+## 環境変数
+
+| 環境変数 | 説明 | 注釈 |
+|--------|-----|-----|
+| `ENGINE_FILES_V3_PATH` | engine-files v3 のビルド成果物のパス。<br> この値が指定された場合、 対象の engine-files を akashic-engine v3 コンテンツ実行時に利用します。 | エンジン開発用のオプションです。通常、ゲーム開発時に利用する必要はありません。 |
+
+## ライセンス
+本リポジトリは MIT License の元で公開されています。
+詳しくは [LICENSE](https://github.com/akashic-games/headless-driver/blob/master/LICENSE) をご覧ください。
+ 
+ただし、画像ファイルおよび音声ファイルは
+[CC BY 2.1 JP](https://creativecommons.org/licenses/by/2.1/jp/) の元で公開されています。

package/lib/ExecuteVmScriptV1.d.ts

@@ -1,4 +1,4 @@
-import { RunnerParameters } from "@akashic/headless-driver-runner";
-import { RunnerV1 } from "@akashic/headless-driver-runner-v1";
+import type { RunnerParameters } from "./runner";
+import { RunnerV1 } from "./runner/v1";
 export declare function createRunnerV1(params: RunnerParameters): RunnerV1;
 export declare function getFilePath(): string;

package/lib/ExecuteVmScriptV1.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFilePath = exports.createRunnerV1 = void 0;
-const headless_driver_runner_v1_1 = require("@akashic/headless-driver-runner-v1");
+const v1_1 = require("./runner/v1");
 function createRunnerV1(params) {
-    return new headless_driver_runner_v1_1.RunnerV1(params);
+    return new v1_1.RunnerV1(params);
 }
 exports.createRunnerV1 = createRunnerV1;
 function getFilePath() {

package/lib/ExecuteVmScriptV2.d.ts

@@ -1,4 +1,4 @@
-import { RunnerParameters } from "@akashic/headless-driver-runner";
-import { RunnerV2 } from "@akashic/headless-driver-runner-v2";
+import type { RunnerParameters } from "./runner";
+import { RunnerV2 } from "./runner/v2";
 export declare function createRunnerV2(params: RunnerParameters): RunnerV2;
 export declare function getFilePath(): string;

package/lib/ExecuteVmScriptV2.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFilePath = exports.createRunnerV2 = void 0;
-const headless_driver_runner_v2_1 = require("@akashic/headless-driver-runner-v2");
+const v2_1 = require("./runner/v2");
 function createRunnerV2(params) {
-    return new headless_driver_runner_v2_1.RunnerV2(params);
+    return new v2_1.RunnerV2(params);
 }
 exports.createRunnerV2 = createRunnerV2;
 function getFilePath() {

package/lib/ExecuteVmScriptV3.d.ts

@@ -1,4 +1,4 @@
-import { RunnerParameters } from "@akashic/headless-driver-runner";
-import { RunnerV3 } from "@akashic/headless-driver-runner-v3";
+import type { RunnerParameters } from "./runner";
+import { RunnerV3 } from "./runner/v3";
 export declare function createRunnerV3(params: RunnerParameters): RunnerV3;
 export declare function getFilePath(): string;

package/lib/ExecuteVmScriptV3.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFilePath = exports.createRunnerV3 = void 0;
-const headless_driver_runner_v3_1 = require("@akashic/headless-driver-runner-v3");
+const v3_1 = require("./runner/v3");
 function createRunnerV3(params) {
-    return new headless_driver_runner_v3_1.RunnerV3(params);
+    return new v3_1.RunnerV3(params);
 }
 exports.createRunnerV3 = createRunnerV3;
 function getFilePath() {

package/lib/Looper.d.ts

@@ -0,0 +1,24 @@
+export declare class Looper {
+    private _running;
+    private _fun;
+    private _timerId;
+    private _prev;
+    private _errorHandler;
+    /**
+     * コンテンツの一時停止を外部からリクエストされているか
+     */
+    private _debugStarted;
+    /**
+     * game-driverがプレイを続行する状態になっているかどうか
+     */
+    private _platformStarted;
+    constructor(fun: (deltaTime: number) => number, errorHandler: (err: any) => void);
+    start(): void;
+    stop(): void;
+    debugStart(): void;
+    debugStop(): void;
+    debugStep(ms: number): void;
+    private _update;
+    private _start;
+    private _stop;
+}

package/lib/Looper.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Looper = void 0;
+class Looper {
+    constructor(fun, errorHandler) {
+        this._fun = fun;
+        this._timerId = null;
+        this._prev = 0;
+        this._errorHandler = errorHandler;
+        this._running = false;
+        this._debugStarted = true;
+        this._platformStarted = false;
+    }
+    start() {
+        this._platformStarted = true;
+        this._update();
+    }
+    stop() {
+        this._platformStarted = false;
+        this._update();
+    }
+    debugStart() {
+        this._debugStarted = true;
+        this._update();
+    }
+    debugStop() {
+        this._debugStarted = false;
+        this._update();
+    }
+    debugStep(ms) {
+        try {
+            this._fun(ms);
+        }
+        catch (e) {
+            this._errorHandler(e);
+        }
+    }
+    _update() {
+        const needsCallRunning = this._debugStarted && this._platformStarted;
+        if (!this._running && needsCallRunning) {
+            this._start();
+        }
+        else if (this._running && !needsCallRunning) {
+            this._stop();
+        }
+    }
+    _start() {
+        this._running = true;
+        try {
+            this._fun(0);
+        }
+        catch (e) {
+            this._errorHandler(e);
+            return;
+        }
+        this._prev = Date.now();
+        this._timerId = setInterval(() => {
+            const now = Date.now();
+            try {
+                this._fun(now - this._prev);
+            }
+            catch (e) {
+                this._errorHandler(e);
+                this._platformStarted = false;
+                this._stop(); // TODO: 例外発生時止めてしまうのがいいのか検討
+            }
+            this._prev = now;
+        }, 16);
+    }
+    _stop() {
+        if (this._timerId != null) {
+            clearInterval(this._timerId);
+        }
+        this._running = false;
+        this._timerId = null;
+        this._prev = 0;
+    }
+}
+exports.Looper = Looper;

package/lib/index.d.ts

@@ -1,12 +1,4 @@
-export * from "./play/amflow/AMFlowClient";
-export * from "./play/Content";
-export * from "./play/Play";
-export * from "./play/AMFlowClientManager";
-export * from "./play/amflow/types";
-export * from "./play/PlayManager";
-export * from "./runner/RunnerManager";
+export * from "./runner";
+export * from "./play";
 export * from "./Logger";
-export * from "@akashic/headless-driver-runner";
-export * from "@akashic/headless-driver-runner-v1";
-export * from "@akashic/headless-driver-runner-v2";
-export * from "@akashic/headless-driver-runner-v3";
+export * from "./Looper";

package/lib/index.js

@@ -10,15 +10,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./play/amflow/AMFlowClient"), exports);
-__exportStar(require("./play/Content"), exports);
-__exportStar(require("./play/Play"), exports);
-__exportStar(require("./play/AMFlowClientManager"), exports);
-__exportStar(require("./play/amflow/types"), exports);
-__exportStar(require("./play/PlayManager"), exports);
-__exportStar(require("./runner/RunnerManager"), exports);
+__exportStar(require("./runner"), exports);
+__exportStar(require("./play"), exports);
 __exportStar(require("./Logger"), exports);
-__exportStar(require("@akashic/headless-driver-runner"), exports);
-__exportStar(require("@akashic/headless-driver-runner-v1"), exports);
-__exportStar(require("@akashic/headless-driver-runner-v2"), exports);
-__exportStar(require("@akashic/headless-driver-runner-v3"), exports);
+__exportStar(require("./Looper"), exports);

package/lib/play/AMFlowClientManager.d.ts

@@ -1,4 +1,4 @@
-import { Permission } from "@akashic/amflow";
+import type { Permission } from "@akashic/amflow";
 import { AMFlowClient } from "./amflow/AMFlowClient";
 export declare class AMFlowClientManager {
     /**

package/lib/play/Play.d.ts

@@ -1,4 +1,4 @@
-import { ContentLocation } from "./Content";
+import type { ContentLocation } from "./Content";
 export declare type PlayStatus = "preparing" | "running" | "suspending" | "broken";
 export declare type Play = ContentLocation & BasePlay;
 export interface BasePlay {

package/lib/play/PlayManager.d.ts

@@ -1,8 +1,8 @@
-import { Permission } from "@akashic/amflow";
-import { AMFlowClient } from "./amflow/AMFlowClient";
-import { DumpedPlaylog } from "./amflow/types";
-import { ContentLocation } from "./Content";
-import { Play, PlayStatus } from "./Play";
+import type { Permission } from "@akashic/amflow";
+import type { AMFlowClient } from "./amflow/AMFlowClient";
+import type { DumpedPlaylog } from "./amflow/types";
+import type { ContentLocation } from "./Content";
+import type { Play, PlayStatus } from "./Play";
 export declare type PlayManagerParameters = ContentLocation;
 export interface PlayFilter {
     status: PlayStatus;

package/lib/play/amflow/AMFlowClient.d.ts

@@ -1,8 +1,8 @@
-import { AMFlow, GetStartPointOptions, GetTickListOptions, Permission, StartPoint } from "@akashic/amflow";
-import { Event, StorageData, StorageKey, StorageReadKey, StorageValue, Tick, TickList } from "@akashic/playlog";
+import type { AMFlow, GetStartPointOptions, GetTickListOptions, Permission, StartPoint } from "@akashic/amflow";
+import type { Event, StorageData, StorageKey, StorageReadKey, StorageValue, Tick, TickList } from "@akashic/playlog";
 import { Trigger } from "@akashic/trigger";
-import { AMFlowStore } from "./AMFlowStore";
-import { DumpedPlaylog } from "./types";
+import type { AMFlowStore } from "./AMFlowStore";
+import type { DumpedPlaylog } from "./types";
 export declare type AMFlowState = "connecting" | "open" | "closing" | "closed";
 /**
  * Runnerと1対1で対応するAMFlow実装。

package/lib/play/amflow/AMFlowStore.d.ts

@@ -1,7 +1,7 @@
-import { GetStartPointOptions, GetTickListOptions, Permission, StartPoint } from "@akashic/amflow";
-import { Event, Tick, TickList } from "@akashic/playlog";
+import type { GetStartPointOptions, GetTickListOptions, Permission, StartPoint } from "@akashic/amflow";
+import type { Event, Tick, TickList } from "@akashic/playlog";
 import { Trigger } from "@akashic/trigger";
-import { DumpedPlaylog } from "./types";
+import type { DumpedPlaylog } from "./types";
 /**
  * AMFlow のストア。
  * 一つのプレーに対して一つ存在する。

package/lib/play/amflow/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./AMFlowClient";
+export * from "./AMFlowStore";
+export * from "./ErrorFactory";
+export * from "./types";

package/lib/play/amflow/index.js

@@ -0,0 +1,16 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./AMFlowClient"), exports);
+__exportStar(require("./AMFlowStore"), exports);
+__exportStar(require("./ErrorFactory"), exports);
+__exportStar(require("./types"), exports);

package/lib/play/amflow/types.d.ts

@@ -1,5 +1,5 @@
-import { StartPoint } from "@akashic/amflow";
-import { TickList } from "@akashic/playlog";
+import type { StartPoint } from "@akashic/amflow";
+import type { TickList } from "@akashic/playlog";
 export interface DumpedPlaylog {
     tickList: TickList | null;
     startPoints: StartPoint[];

package/lib/play/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./AMFlowClientManager";
+export * from "./Play";
+export * from "./PlayManager";
+export * from "./Content";
+export * from "./amflow";

package/lib/play/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./AMFlowClientManager"), exports);
+__exportStar(require("./Play"), exports);
+__exportStar(require("./PlayManager"), exports);
+__exportStar(require("./Content"), exports);
+__exportStar(require("./amflow"), exports);

package/lib/runner/Platform.d.ts

@@ -0,0 +1,25 @@
+import type { AMFlow } from "@akashic/amflow";
+import type { RunnerRenderingMode } from "./types";
+export interface PlatformParameters {
+    assetBaseUrl: string;
+    configurationBaseUrl?: string;
+    amflow: AMFlow;
+    sendToExternalHandler: (data: any) => void;
+    trusted?: boolean;
+    renderingMode?: RunnerRenderingMode;
+    errorHandler: (err: any) => void;
+    loadFileHandler: (url: string, callback: (err: Error | null, data?: string) => void) => void;
+}
+export declare abstract class Platform {
+    amflow: AMFlow;
+    assetBaseUrl: string;
+    configurationBaseUrl: string | undefined;
+    trusted: boolean;
+    renderingMode: RunnerRenderingMode;
+    protected sendToExternalHandler: (data: any) => void;
+    protected errorHandler: (err: any) => void;
+    protected loadFileHandler: (url: string, callback: (err: Error | null, data?: string) => void) => void;
+    constructor(param: PlatformParameters);
+    sendToExternal(_playId: string, data: any): void;
+    loadGameConfiguration: (url: string, callback: (err: Error | null, data?: string | undefined) => void) => void;
+}

package/lib/runner/Platform.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Platform = void 0;
+class Platform {
+    constructor(param) {
+        var _a;
+        // eslint-disable-next-line @typescript-eslint/typedef
+        this.loadGameConfiguration = (url, callback) => {
+            this.loadFileHandler(url, (err, str) => {
+                if (err) {
+                    callback(err);
+                }
+                else if (!str) {
+                    callback(new Error("Platform#loadGameConfiguration(): No data received"));
+                }
+                else {
+                    callback(null, JSON.parse(str));
+                }
+            });
+        };
+        this.assetBaseUrl = param.assetBaseUrl;
+        this.configurationBaseUrl = param.configurationBaseUrl;
+        this.amflow = param.amflow;
+        this.trusted = !!param.trusted;
+        this.renderingMode = (_a = param.renderingMode) !== null && _a !== void 0 ? _a : "none";
+        this.sendToExternalHandler = param.sendToExternalHandler;
+        this.errorHandler = param.errorHandler;
+        this.loadFileHandler = param.loadFileHandler;
+    }
+    sendToExternal(_playId, data) {
+        this.sendToExternalHandler(data);
+    }
+}
+exports.Platform = Platform;

package/lib/runner/Runner.d.ts

@@ -0,0 +1,110 @@
+import type { AMFlow } from "@akashic/amflow";
+import { Trigger } from "@akashic/trigger";
+import type { Platform } from "./Platform";
+import type { RunnerAdvanceConditionFunc, RunnerExecutionMode, RunnerPlayer, RunnerPointEvent, RunnerRenderingMode } from "./types";
+export interface RunnerParameters {
+    contentUrl: string;
+    assetBaseUrl: string;
+    configurationUrl: string;
+    configurationBaseUrl?: string;
+    playId: string;
+    playToken: string;
+    runnerId: string;
+    amflow: AMFlow;
+    executionMode: RunnerExecutionMode;
+    trusted?: boolean;
+    renderingMode?: RunnerRenderingMode;
+    loadFileHandler: (url: string, callback: (err: Error | null, data?: string) => void) => void;
+    external?: {
+        [key: string]: string;
+    };
+    gameArgs?: any;
+    player?: RunnerPlayer;
+    externalValue?: {
+        [key: string]: any;
+    };
+}
+export interface RunnerStartParameters {
+    /**
+     * コンテンツの進行を一時停止するかどうか。
+     * 初期値は `false` 。
+     */
+    paused?: boolean;
+}
+export declare abstract class Runner {
+    abstract readonly engineVersion: string;
+    /**
+     * g の名前空間のオブジェクト。`g.game` は `undefined` であることに注意。
+     */
+    abstract readonly g: any;
+    abstract platform: Platform | null;
+    errorTrigger: Trigger<Error>;
+    sendToExternalTrigger: Trigger<any>;
+    private params;
+    get runnerId(): string;
+    get playId(): string;
+    get playToken(): string;
+    get contentUrl(): string;
+    get assetBaseUrl(): string;
+    get configurationUrl(): string;
+    get configurationBaseUrl(): string | undefined;
+    get amflow(): AMFlow;
+    get executionMode(): RunnerExecutionMode;
+    get trusted(): boolean;
+    get renderingMode(): RunnerRenderingMode;
+    get loadFileHandler(): (url: string, callback: (err: Error | null, data?: string) => void) => void;
+    get gameArgs(): any;
+    get player(): RunnerPlayer | undefined;
+    get external(): {
+        [key: string]: string;
+    } | undefined;
+    get externalValue(): {
+        [key: string]: any;
+    } | undefined;
+    constructor(params: RunnerParameters);
+    /**
+     * Runner を開始する。
+     * @param params 起動時に必要なパラメータ。
+     * @returns `g.game` のインスタンス。起動に失敗した場合は `null` 。
+     */
+    abstract start(params?: RunnerStartParameters): any;
+    /**
+     * Runner を停止する。
+     */
+    abstract stop(): void;
+    /**
+     * Runner を一時停止する。
+     */
+    abstract pause(): void;
+    /**
+     * Runner を再開する。
+     */
+    abstract resume(): void;
+    /**
+     * Runner を指定ミリ秒だけ進行する。
+     * @param ms 進行するミリ秒。
+     */
+    abstract advance(ms: number): void;
+    /**
+     * Runner を一フレーム進行する。
+     */
+    abstract step(): void;
+    /**
+     * Runner に対して任意のポイントイベントを発火させる。
+     * @param event 発火させるポイントイベント
+     */
+    abstract firePointEvent(event: RunnerPointEvent): void;
+    /**
+     * 実行中コンテンツのプライマリサーフェスを取得する。
+     * @returns プライマリサーフェスのインスタンス。
+     */
+    abstract getPrimarySurface(): any;
+    /**
+     * 引数に指定した関数が真を返すまでゲームの状態を進める。
+     * @param condition 進めるまでの条件となる関数。
+     * @param timeout タイムアウトまでのミリ秒数。省略時は `5000` 。ゲーム内時間ではなく実時間である点に注意。
+     */
+    advanceUntil(condition: RunnerAdvanceConditionFunc, timeout?: number): Promise<void>;
+    protected abstract _stepMinimal(): void;
+    protected onError(error: Error): void;
+}

package/lib/runner/Runner.js

@@ -0,0 +1,101 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Runner = void 0;
+const trigger_1 = require("@akashic/trigger");
+class Runner {
+    constructor(params) {
+        this.errorTrigger = new trigger_1.Trigger();
+        this.sendToExternalTrigger = new trigger_1.Trigger();
+        this.params = params;
+    }
+    get runnerId() {
+        return this.params.runnerId;
+    }
+    get playId() {
+        return this.params.playId;
+    }
+    get playToken() {
+        return this.params.playToken;
+    }
+    get contentUrl() {
+        return this.params.contentUrl;
+    }
+    get assetBaseUrl() {
+        return this.params.assetBaseUrl;
+    }
+    get configurationUrl() {
+        return this.params.configurationUrl;
+    }
+    get configurationBaseUrl() {
+        return this.params.configurationBaseUrl;
+    }
+    get amflow() {
+        return this.params.amflow;
+    }
+    get executionMode() {
+        return this.params.executionMode;
+    }
+    get trusted() {
+        return !!this.params.trusted;
+    }
+    get renderingMode() {
+        var _a;
+        return (_a = this.params.renderingMode) !== null && _a !== void 0 ? _a : "none";
+    }
+    get loadFileHandler() {
+        return this.params.loadFileHandler;
+    }
+    get gameArgs() {
+        return this.params.gameArgs;
+    }
+    get player() {
+        return this.params.player;
+    }
+    get external() {
+        return this.params.external;
+    }
+    get externalValue() {
+        return this.params.externalValue;
+    }
+    /**
+     * 引数に指定した関数が真を返すまでゲームの状態を進める。
+     * @param condition 進めるまでの条件となる関数。
+     * @param timeout タイムアウトまでのミリ秒数。省略時は `5000` 。ゲーム内時間ではなく実時間である点に注意。
+     */
+    advanceUntil(condition, timeout = 5000) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const limit = Date.now() + timeout;
+                const handler = () => {
+                    if (limit < Date.now()) {
+                        return void reject(new Error("Runner#advanceUntil(): processing timeout"));
+                    }
+                    try {
+                        if (condition())
+                            return void resolve();
+                        this._stepMinimal();
+                    }
+                    catch (e) {
+                        return void reject(e);
+                    }
+                    setImmediate(handler);
+                };
+                handler();
+            });
+        });
+    }
+    onError(error) {
+        this.stop();
+        this.errorTrigger.fire(error);
+    }
+}
+exports.Runner = Runner;

package/lib/runner/RunnerManager.d.ts

@@ -1,10 +1,10 @@
-import { RunnerExecutionMode, RunnerPlayer, RunnerRenderingMode } from "@akashic/headless-driver-runner";
-import { RunnerV1, RunnerV1Game } from "@akashic/headless-driver-runner-v1";
-import { RunnerV2, RunnerV2Game } from "@akashic/headless-driver-runner-v2";
-import { RunnerV3, RunnerV3Game } from "@akashic/headless-driver-runner-v3";
 import { NodeVM } from "vm2";
-import { AMFlowClient } from "../play/amflow/AMFlowClient";
-import { PlayManager } from "../play/PlayManager";
+import type { AMFlowClient } from "../play/amflow/AMFlowClient";
+import type { PlayManager } from "../play/PlayManager";
+import type { RunnerExecutionMode, RunnerPlayer, RunnerRenderingMode } from "./types";
+import type { RunnerV1, RunnerV1Game } from "./v1";
+import type { RunnerV2, RunnerV2Game } from "./v2";
+import type { RunnerV3, RunnerV3Game } from "./v3";
 export interface CreateRunnerParameters {
     playId: string;
     amflow: AMFlowClient;

package/lib/runner/RunnerManager.js

@@ -13,13 +13,13 @@ exports.RunnerManager = void 0;
 const fs = require("fs");
 const path = require("path");
 const url = require("url");
-const requireEngineFiles_1 = require("@akashic/headless-driver-runner-v3/lib/requireEngineFiles");
 const vm2_1 = require("vm2");
+const ExecVmScriptV3 = require("..//ExecuteVmScriptV3");
 const ExecVmScriptV1 = require("../ExecuteVmScriptV1");
 const ExecVmScriptV2 = require("../ExecuteVmScriptV2");
-const ExecVmScriptV3 = require("../ExecuteVmScriptV3");
 const Logger_1 = require("../Logger");
 const utils_1 = require("../utils");
+const requireEngineFiles_1 = require("./v3/requireEngineFiles");
 /**
  * Runner を管理するマネージャ。
  */