keystonemc 1.0.0 → 1.0.1

package/dist/core/event/eventManager.d.ts

@@ -0,0 +1,33 @@
+import { world } from '@minecraft/server';
+import { Listener } from './types';
+/**
+ * AfterEventMap / BeforeEventMap を world.afterEvents / world.beforeEvents の
+ * subscribe のハンドラ引数から自動抽出する。
+ *
+ * 例: world.afterEvents.playerSpawn.subscribe((ev: PlayerSpawnAfterEvent) => {...})
+ *    の ev の型を自動的に E として取り出す。
+ */
+type ExtractSubscribeArg<T> = T extends {
+    subscribe: (handler: (ev: infer E) => any) => any;
+} ? E : never;
+export type AfterEventMap = {
+    [K in keyof typeof world.afterEvents]: ExtractSubscribeArg<(typeof world.afterEvents)[K]>;
+};
+export type BeforeEventMap = {
+    [K in keyof typeof world.beforeEvents]: ExtractSubscribeArg<(typeof world.beforeEvents)[K]>;
+};
+type AfterEventName = keyof AfterEventMap;
+type BeforeEventName = keyof BeforeEventMap;
+export declare class EventManager {
+    private static afterListeners;
+    private static beforeListeners;
+    /** init: world.beforeEvents / world.afterEvents を全自動で subscribe して dispatch に流す */
+    static initialize(): void;
+    static registerAfter<K extends AfterEventName>(eventName: K, listener: Listener<AfterEventMap[K]>): void;
+    static registerBefore<K extends BeforeEventName>(eventName: K, listener: Listener<BeforeEventMap[K]>): void;
+    private static dispatchAfter;
+    private static dispatchBefore;
+    /** 登録済みリスナーを全部クリア（Plugin 単位で実装するなら拡張する） */
+    private static clearAll;
+}
+export {};

package/dist/core/event/flow.d.ts

@@ -0,0 +1,18 @@
+interface WaitForOptions {
+    onInterval?: () => void;
+    onTimeout?: () => void;
+    interval?: number;
+    timeout?: number;
+    resolveOnInterval?: boolean;
+    resolveOnTimeout?: boolean;
+}
+/**
+ * イベントを条件付きで待機（タイムアウト付き）
+ */
+export declare function waitFor<T extends object>(predicate: (event: T) => boolean, options?: WaitForOptions): Promise<T>;
+/**
+ * 複数イベントを束ねて非同期フローを開始
+ * すべてのイベントで、Entityを自動検出
+ */
+export declare function flowListen<E extends object>(...args: any[]): void;
+export {};

package/dist/core/event/priority.d.ts

@@ -0,0 +1,8 @@
+export declare enum Priority {
+    LOWEST = 5,
+    LOW = 4,
+    NORMAL = 3,
+    HIGH = 2,
+    HIGHEST = 1,
+    MONITOR = 0
+}

package/dist/core/event/types.d.ts

@@ -0,0 +1,6 @@
+import { Priority } from './priority';
+/** リスナー型 */
+export interface Listener<T> {
+    handler(event: T): void;
+    priority?: Priority;
+}

package/dist/core/index.d.ts

@@ -0,0 +1,6 @@
+export { keystone } from './keystone';
+export { Vector3 } from './math/vector3';
+export { Priority } from './event/priority';
+export { EventManager } from './event/eventManager';
+export { debug } from './utils/debugger';
+export { RepeatingTimer, DelayedTimer, repeating, delayed, sleep } from './timer/timer';

package/dist/core/keystone.d.ts

@@ -0,0 +1,5 @@
+declare class Keystone {
+    constructor();
+}
+export declare const keystone: Keystone;
+export {};

package/dist/core/math/vector3.d.ts

@@ -0,0 +1,195 @@
+import { Vector3 as _Vector3 } from '@minecraft/server';
+export declare class Vector3 {
+    x: number;
+    y: number;
+    z: number;
+    constructor(x: number, y: number, z: number);
+    /**
+     * ゼロベクトルで生成
+     * @return {Vector3}
+     */
+    static zero(): Vector3;
+    /**
+     * {x, y, z} オブジェクトから生成
+     * @param {_Vector3} pos
+     * @returns
+     */
+    static fromBDS(pos: _Vector3): Vector3;
+    getX(): number;
+    getY(): number;
+    getZ(): number;
+    getFloorX(): number;
+    getFloorY(): number;
+    getFloorZ(): number;
+    /**
+     * 加算
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @return {Vector3}
+     */
+    add(x: number, y: number, z: number): Vector3;
+    /**
+     * ベクトル単位での加算
+     * @param {_Vector3} v
+     * @returns {Vector3}
+     */
+    addVector(v: _Vector3): Vector3;
+    /**
+     * 減算
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @return {Vector3}
+     */
+    subtract(x: number, y: number, z: number): Vector3;
+    /**
+     * ベクトル単位での減算
+     * @param {_Vector3} v
+     * @return {Vector3}
+     */
+    subtractVector(v: _Vector3): Vector3;
+    /**
+     * 乗算
+     * @param {number} value
+     * @return {Vector3}
+     */
+    multiply(value: number): Vector3;
+    /**
+     * 除算
+     * @param {number} value
+     * @return {Vector3}
+     */
+    divide(value: number): Vector3;
+    /**
+     * ベクトルの内部数値小数点切り上げ
+     * @return {Vector3}
+     */
+    ceil(): Vector3;
+    /**
+     * ベクトルの内部数値小数点切り捨て
+     * @return {Vector3}
+     */
+    floor(): Vector3;
+    /**
+     * ベクトルの内部数値小数点四捨五入
+     * @param {number} precision
+     * @return {Vector3}
+     */
+    round(precision?: number): Vector3;
+    /**
+     * ベクトルの内部数値の絶対値
+     * @return {Vector3}
+     */
+    abs(): Vector3;
+    /**
+     * 指定した2点間のユークリッド距離
+     * @param {_Vector3} pos
+     * @return {number}
+     */
+    distance(pos: _Vector3): number;
+    /**
+     * 指定した2点間のユークリッド距離の2乗
+     * @param {_Vector3} pos
+     * @return {number}
+     */
+    distanceSquared(pos: _Vector3): number;
+    /**
+     * 内積
+     * @param {_Vector3} pos
+     * @return {number}
+     */
+    dot(pos: _Vector3): number;
+    /**
+     * 外積
+     * @param {_Vector3} pos
+     * @return {Vector3}
+     */
+    cross(pos: _Vector3): Vector3;
+    /**
+     * ベクトルの比較
+     * @param {_Vector3} pos
+     * @return {boolean}
+     */
+    equals(pos: _Vector3): boolean;
+    /**
+     * ベクトルの長さ
+     * @return {number}
+     */
+    length(): number;
+    /**
+     * ベクトルの長さの2乗
+     * @return {number}
+     */
+    lengthSquared(): number;
+    /**
+     * 正規化
+     * @return {Vector3}
+     */
+    normalize(): Vector3;
+    /**
+     * オブジェクトの数値指定再生成
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @return {Vector3}
+     */
+    withComponents(x?: number, y?: number, z?: number): Vector3;
+    /**
+   * X座標をxValueにしたとき線分上に存在する点を返す
+   * @param end 終点
+   * @param xValue 途中点のX値
+   * @returns {Vector3 | undefined}
+   */
+    getIntermediateWithXValue(end: Vector3, xValue: number): Vector3 | undefined;
+    /**
+     * Y座標をyValueにしたとき線分上に存在する点を返す
+     * @param end 終点
+     * @param yValue 途中点のY値
+     * @returns {Vector3 | undefined}
+     */
+    getIntermediateWithYValue(end: Vector3, yValue: number): Vector3 | undefined;
+    /**
+     * Z座標をzValueにしたとき線分上に存在する点を返す
+     * @param end 終点
+     * @param zValue 途中点のZ値
+     * @returns {Vector3 | undefined}
+     */
+    getIntermediateWithZValue(end: Vector3, zValue: number): Vector3 | undefined;
+    /**
+     * BDS ScriptAPIで使える {x, y, z} 形式に変換
+     * @returns {_Vector3}
+     */
+    toBDS(): _Vector3;
+    /** 通常のオブジェクトに変換 */
+    toObject(): {
+        x: number;
+        y: number;
+        z: number;
+    };
+    toString(): string;
+    /**
+     * 最大点
+     * @param {_Vector3} vector
+     * @param {_Vector3[]} vectors
+     * @returns {Vector3}
+     */
+    static maxComponents(vector: _Vector3, ...vectors: _Vector3[]): Vector3;
+    /**
+     * 最小点
+     * @param {_Vector3} vector
+     * @param {_Vector3[]} vectors
+     * @returns {Vector3}
+     */
+    static minComponents(vector: _Vector3, ...vectors: _Vector3[]): Vector3;
+    /**
+     * 合計
+     * @param {_Vector3[]} vectors
+     * @returns {Vector3}
+     */
+    static sum(...vectors: {
+        x: number;
+        y: number;
+        z: number;
+    }[]): Vector3;
+}

package/dist/core/timer/timer.d.ts

@@ -0,0 +1,94 @@
+/**
+ * ============================================================
+ * マスター Interval（負荷分散スケジューラ）
+ * ============================================================
+ */
+export declare class TimerScheduler {
+    private static tasks;
+    private static tick;
+    private static started;
+    /** スケジューラにタスクを登録 */
+    static addTask(task: () => void): void;
+    /** タスクを削除 */
+    static removeTask(task: () => void): void;
+    /** Interval を開始（1 本だけ） */
+    private static ensureStarted;
+}
+/** 内部キャンセル結果 */
+declare enum CancelResult {
+    SUCCESS = 0,
+    FORCE = 1,
+    FAILURE = 2
+}
+/**
+ * ============================================================
+ * Base Timer
+ * ============================================================
+ * スケジューラに登録され、tick ごとに管理される抽象クラス
+ */
+declare abstract class Timer {
+    protected currentTick: number;
+    protected onRun?: (currentTick: number) => void;
+    protected onCancel?: () => void;
+    protected stopped: boolean;
+    protected canceled: boolean;
+    protected forceCanceled: boolean;
+    /** スケジューラに登録されたタスク */
+    protected task?: () => void;
+    constructor(onRun?: (currentTick: number) => void, onCancel?: () => void);
+    /** 開始（各派生クラスで実装） */
+    abstract start(): void;
+    /** 一時停止 */
+    stop(): void;
+    /** 再開 */
+    resume(): void;
+    /** 停止しているか */
+    isStopped(): boolean;
+    /** キャンセル要求 */
+    cancel(force?: boolean): void;
+    /** タイマー内部キャンセル */
+    protected internalCancel(force?: boolean): CancelResult;
+}
+export interface RepeatingOptions {
+    period?: number;
+    endless?: boolean;
+    silenceOnStop?: boolean;
+    maxElapsedTicks?: number;
+    onFinal?: () => void;
+}
+/**
+ * 一定間隔で実行される繰り返しタイマー
+ */
+export declare class RepeatingTimer extends Timer {
+    private period;
+    private endless;
+    private silenceOnStop;
+    private maxElapsedTicks?;
+    private onFinal?;
+    constructor(onRun?: (currentTick: number) => void, opts?: RepeatingOptions, onCancel?: () => void);
+    /** タイマー開始 */
+    start(): void;
+}
+export interface DelayedOptions {
+    delay?: number;
+}
+/**
+ * 指定 tick 後に一度だけ実行されるタイマー
+ */
+export declare class DelayedTimer extends Timer {
+    private delay;
+    constructor(onRun?: (currentTick: number) => void, opts?: DelayedOptions, onCancel?: () => void);
+    start(): void;
+}
+export declare function repeating(opts: {
+    every?: number;
+    endless?: boolean;
+    max?: number;
+    silenceWhenStopped?: boolean;
+    run?: (tick: number) => void;
+    cancel?: () => void;
+    final?: () => void;
+}): RepeatingTimer;
+export declare function delayed(ticks: number, run: () => void, cancel?: () => void): DelayedTimer;
+export declare function sleep(tick: number): Promise<void>;
+export {};

package/dist/core/utils/debugger.d.ts

@@ -0,0 +1 @@
+export declare function debug(...args: any[]): void;

package/dist/index.js

@@ -0,0 +1,770 @@
+import { world, system } from "@minecraft/server";
+class Keystone {
+  constructor() {
+  }
+}
+const keystone = new Keystone();
+class Vector3 {
+  constructor(x, y, z) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+  }
+  /**
+   * ゼロベクトルで生成
+   * @return {Vector3}
+   */
+  static zero() {
+    return new Vector3(0, 0, 0);
+  }
+  /**
+   * {x, y, z} オブジェクトから生成
+   * @param {_Vector3} pos 
+   * @returns 
+   */
+  static fromBDS(pos) {
+    return new Vector3(pos.x, pos.y, pos.z);
+  }
+  // ===== 基本ゲッター =====
+  getX() {
+    return this.x;
+  }
+  getY() {
+    return this.y;
+  }
+  getZ() {
+    return this.z;
+  }
+  getFloorX() {
+    return Math.floor(this.x);
+  }
+  getFloorY() {
+    return Math.floor(this.y);
+  }
+  getFloorZ() {
+    return Math.floor(this.z);
+  }
+  /**
+   * 加算
+   * @param {number} x 
+   * @param {number} y 
+   * @param {number} z 
+   * @return {Vector3}
+   */
+  add(x, y, z) {
+    return new Vector3(
+      this.x + x,
+      this.y + y,
+      this.z + z
+    );
+  }
+  /**
+   * ベクトル単位での加算
+   * @param {_Vector3} v 
+   * @returns {Vector3}
+   */
+  addVector(v) {
+    return this.add(v.x, v.y, v.z);
+  }
+  /**
+   * 減算
+   * @param {number} x
+   * @param {number} y
+   * @param {number} z
+   * @return {Vector3}
+   */
+  subtract(x, y, z) {
+    return this.add(-x, -y, -z);
+  }
+  /**
+   * ベクトル単位での減算
+   * @param {_Vector3} v
+   * @return {Vector3}
+   */
+  subtractVector(v) {
+    return this.add(-v.x, -v.y, -v.z);
+  }
+  /**
+   * 乗算
+   * @param {number} value
+   * @return {Vector3}
+   */
+  multiply(value) {
+    return new Vector3(
+      this.x * value,
+      this.y * value,
+      this.z * value
+    );
+  }
+  /**
+   * 除算
+   * @param {number} value
+   * @return {Vector3}
+   */
+  divide(value) {
+    return new Vector3(
+      this.x / value,
+      this.y / value,
+      this.z / value
+    );
+  }
+  /**
+   * ベクトルの内部数値小数点切り上げ
+   * @return {Vector3}
+   */
+  ceil() {
+    return new Vector3(
+      Math.ceil(this.x),
+      Math.ceil(this.y),
+      Math.ceil(this.z)
+    );
+  }
+  /**
+   * ベクトルの内部数値小数点切り捨て
+   * @return {Vector3}
+   */
+  floor() {
+    return new Vector3(
+      Math.floor(this.x),
+      Math.floor(this.y),
+      Math.floor(this.z)
+    );
+  }
+  /**
+   * ベクトルの内部数値小数点四捨五入
+   * @param {number} precision
+   * @return {Vector3}
+   */
+  round(precision = 0) {
+    const factor = Math.pow(10, precision);
+    return new Vector3(
+      Math.round(this.x * factor) / factor,
+      Math.round(this.y * factor) / factor,
+      Math.round(this.z * factor) / factor
+    );
+  }
+  /**
+   * ベクトルの内部数値の絶対値
+   * @return {Vector3}
+   */
+  abs() {
+    return new Vector3(
+      Math.abs(this.x),
+      Math.abs(this.y),
+      Math.abs(this.z)
+    );
+  }
+  /**
+   * 指定した2点間のユークリッド距離
+   * @param {_Vector3} pos 
+   * @return {number}
+   */
+  distance(pos) {
+    return Math.sqrt(this.distanceSquared(pos));
+  }
+  /**
+   * 指定した2点間のユークリッド距離の2乗
+   * @param {_Vector3} pos 
+   * @return {number}
+   */
+  distanceSquared(pos) {
+    const dx = this.x - pos.x;
+    const dy = this.y - pos.y;
+    const dz = this.z - pos.z;
+    return dx * dx + dy * dy + dz * dz;
+  }
+  /**
+   * 内積
+   * @param {_Vector3} pos 
+   * @return {number}
+   */
+  dot(pos) {
+    return this.x * pos.x + this.y * pos.y + this.z * pos.z;
+  }
+  /**
+   * 外積
+   * @param {_Vector3} pos 
+   * @return {Vector3}
+   */
+  cross(pos) {
+    return new Vector3(
+      this.y * pos.z - this.z * pos.y,
+      this.z * pos.x - this.x * pos.z,
+      this.x * pos.y - this.y * pos.x
+    );
+  }
+  /**
+   * ベクトルの比較
+   * @param {_Vector3} pos 
+   * @return {boolean}
+   */
+  equals(pos) {
+    return this.x === pos.x && this.y === pos.y && this.z === pos.z;
+  }
+  /**
+   * ベクトルの長さ
+   * @return {number}
+   */
+  length() {
+    return Math.sqrt(this.lengthSquared());
+  }
+  /**
+   * ベクトルの長さの2乗
+   * @return {number}
+   */
+  lengthSquared() {
+    return this.x * this.x + this.y * this.y + this.z * this.z;
+  }
+  /**
+   * 正規化
+   * @return {Vector3}
+   */
+  normalize() {
+    const len = this.length();
+    if (len > 0) {
+      return this.divide(len);
+    }
+    return new Vector3(0, 0, 0);
+  }
+  /**
+   * オブジェクトの数値指定再生成
+   * @param {number} x 
+   * @param {number} y 
+   * @param {number} z 
+   * @return {Vector3}
+   */
+  withComponents(x, y, z) {
+    return new Vector3(
+      x !== void 0 ? x : this.x,
+      y !== void 0 ? y : this.y,
+      z !== void 0 ? z : this.z
+    );
+  }
+  /**
+  * X座標をxValueにしたとき線分上に存在する点を返す
+  * @param end 終点
+  * @param xValue 途中点のX値
+  * @returns {Vector3 | undefined}
+  */
+  getIntermediateWithXValue(end, xValue) {
+    const dx = end.x - this.x;
+    if (dx === 0) return;
+    const t = (xValue - this.x) / dx;
+    if (t < 0 || t > 1) return;
+    return new Vector3(
+      this.x + dx * t,
+      this.y + (end.y - this.y) * t,
+      this.z + (end.z - this.z) * t
+    );
+  }
+  /**
+   * Y座標をyValueにしたとき線分上に存在する点を返す
+   * @param end 終点
+   * @param yValue 途中点のY値
+   * @returns {Vector3 | undefined}
+   */
+  getIntermediateWithYValue(end, yValue) {
+    const dy = end.y - this.y;
+    if (dy === 0) return;
+    const t = (yValue - this.y) / dy;
+    if (t < 0 || t > 1) return;
+    return new Vector3(
+      this.x + (end.x - this.x) * t,
+      this.y + dy * t,
+      this.z + (end.z - this.z) * t
+    );
+  }
+  /**
+   * Z座標をzValueにしたとき線分上に存在する点を返す
+   * @param end 終点
+   * @param zValue 途中点のZ値
+   * @returns {Vector3 | undefined}
+   */
+  getIntermediateWithZValue(end, zValue) {
+    const dz = end.z - this.z;
+    if (dz === 0) return;
+    const t = (zValue - this.z) / dz;
+    if (t < 0 || t > 1) return;
+    return new Vector3(
+      this.x + (end.x - this.x) * t,
+      this.y + (end.y - this.y) * t,
+      this.z + dz * t
+    );
+  }
+  /**
+   * BDS ScriptAPIで使える {x, y, z} 形式に変換
+   * @returns {_Vector3}
+   */
+  toBDS() {
+    return { x: this.x, y: this.y, z: this.z };
+  }
+  /** 通常のオブジェクトに変換 */
+  toObject() {
+    return { x: this.x, y: this.y, z: this.z };
+  }
+  toString() {
+    return `_Vector3(x=${this.x}, y=${this.y}, z=${this.z})`;
+  }
+  /**
+   * 最大点
+   * @param {_Vector3} vector
+   * @param {_Vector3[]} vectors 
+   * @returns {Vector3}
+   */
+  static maxComponents(vector, ...vectors) {
+    let x = vector.x;
+    let y = vector.y;
+    let z = vector.z;
+    for (const pos of vectors) {
+      x = Math.max(x, pos.x);
+      y = Math.max(y, pos.y);
+      z = Math.max(z, pos.z);
+    }
+    return new Vector3(x, y, z);
+  }
+  /**
+   * 最小点
+   * @param {_Vector3} vector
+   * @param {_Vector3[]} vectors 
+   * @returns {Vector3}
+   */
+  static minComponents(vector, ...vectors) {
+    let x = vector.x;
+    let y = vector.y;
+    let z = vector.z;
+    for (const pos of vectors) {
+      x = Math.min(x, pos.x);
+      y = Math.min(y, pos.y);
+      z = Math.min(z, pos.z);
+    }
+    return new Vector3(x, y, z);
+  }
+  /**
+   * 合計
+   * @param {_Vector3[]} vectors
+   * @returns {Vector3}
+   */
+  static sum(...vectors) {
+    let x = 0, y = 0, z = 0;
+    for (const v of vectors) {
+      x += v.x;
+      y += v.y;
+      z += v.z;
+    }
+    return new Vector3(x, y, z);
+  }
+}
+var Priority = /* @__PURE__ */ ((Priority2) => {
+  Priority2[Priority2["LOWEST"] = 5] = "LOWEST";
+  Priority2[Priority2["LOW"] = 4] = "LOW";
+  Priority2[Priority2["NORMAL"] = 3] = "NORMAL";
+  Priority2[Priority2["HIGH"] = 2] = "HIGH";
+  Priority2[Priority2["HIGHEST"] = 1] = "HIGHEST";
+  Priority2[Priority2["MONITOR"] = 0] = "MONITOR";
+  return Priority2;
+})(Priority || {});
+const _EventManager = class _EventManager {
+  /** init: world.beforeEvents / world.afterEvents を全自動で subscribe して dispatch に流す */
+  static initialize() {
+    for (const name in world.afterEvents) {
+      world.afterEvents[name].subscribe((ev) => {
+        _EventManager.dispatchAfter(name, ev);
+      });
+    }
+    for (const name in world.beforeEvents) {
+      world.beforeEvents[name].subscribe((ev) => {
+        _EventManager.dispatchBefore(name, ev);
+      });
+    }
+  }
+  // ---------- register ----------
+  static registerAfter(eventName, listener) {
+    if (!this.afterListeners[eventName]) {
+      this.afterListeners[eventName] = [];
+    }
+    const arr = this.afterListeners[eventName];
+    arr.push(listener);
+    arr.sort((a, b) => (b.priority ?? Priority.NORMAL) - (a.priority ?? Priority.NORMAL));
+  }
+  static registerBefore(eventName, listener) {
+    if (!this.beforeListeners[eventName]) {
+      this.beforeListeners[eventName] = [];
+    }
+    const arr = this.beforeListeners[eventName];
+    arr.push(listener);
+    arr.sort((a, b) => (b.priority ?? Priority.NORMAL) - (a.priority ?? Priority.NORMAL));
+  }
+  // ---------- dispatch ----------
+  static dispatchAfter(eventName, event) {
+    const arr = this.afterListeners[eventName];
+    if (!arr) return;
+    for (const listener of arr) {
+      try {
+        listener.handler(event);
+      } catch (e) {
+        console.error(`[EventManager] after:${String(eventName)} handler threw:`, e);
+      }
+    }
+  }
+  static dispatchBefore(eventName, event) {
+    const arr = this.beforeListeners[eventName];
+    if (!arr) return;
+    for (const listener of arr) {
+      try {
+        listener.handler(event);
+      } catch (e) {
+        console.error(`[EventManager] before:${String(eventName)} handler threw:`, e);
+      }
+    }
+  }
+  // ---------- utility ----------
+  /** 登録済みリスナーを全部クリア（Plugin 単位で実装するなら拡張する） */
+  static clearAll() {
+    this.afterListeners = {};
+    this.beforeListeners = {};
+  }
+};
+_EventManager.afterListeners = {};
+_EventManager.beforeListeners = {};
+let EventManager = _EventManager;
+const COLOR = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m"
+};
+const _VLQDecoder = class _VLQDecoder {
+  static decode(str) {
+    const result = [];
+    let shift = 0;
+    let value = 0;
+    for (let i = 0; i < str.length; i++) {
+      const digit = this.BASE64_CHARS.indexOf(str[i]);
+      if (digit === -1) continue;
+      const continuation = (digit & 32) !== 0;
+      value += (digit & 31) << shift;
+      if (continuation) {
+        shift += 5;
+      } else {
+        const negative = (value & 1) !== 0;
+        value >>>= 1;
+        result.push(negative ? -value : value);
+        value = 0;
+        shift = 0;
+      }
+    }
+    return result;
+  }
+};
+_VLQDecoder.BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+let VLQDecoder = _VLQDecoder;
+class SourceMapDebugger {
+  constructor() {
+    this.decodedMappings = [];
+    this.initialized = false;
+    this.initialize();
+  }
+  initialize() {
+    if (typeof globalThis.__SOURCE_MAP__ !== "undefined") {
+      this.sourceMap = globalThis.__SOURCE_MAP__;
+      this.decodeMappings();
+      this.initialized = true;
+    }
+  }
+  decodeMappings() {
+    if (!this.sourceMap?.mappings) return;
+    const lines = this.sourceMap.mappings.split(";");
+    let generatedLine = 1;
+    let prevOriginalLine = 0;
+    let prevOriginalColumn = 0;
+    let prevSource = 0;
+    let prevName = 0;
+    for (const line of lines) {
+      if (!line) {
+        generatedLine++;
+        continue;
+      }
+      const segments = line.split(",");
+      let generatedColumn = 0;
+      for (const segment of segments) {
+        if (!segment) continue;
+        const decoded = VLQDecoder.decode(segment);
+        if (decoded.length < 1) continue;
+        generatedColumn += decoded[0];
+        const mapping = {
+          generatedLine,
+          generatedColumn,
+          originalLine: 0,
+          originalColumn: 0,
+          sourceIndex: 0
+        };
+        if (decoded.length > 1) {
+          prevSource += decoded[1];
+          mapping.sourceIndex = prevSource;
+          if (decoded.length > 2) {
+            prevOriginalLine += decoded[2];
+            mapping.originalLine = prevOriginalLine;
+            if (decoded.length > 3) {
+              prevOriginalColumn += decoded[3];
+              mapping.originalColumn = prevOriginalColumn;
+              if (decoded.length > 4) {
+                prevName += decoded[4];
+                mapping.name = this.sourceMap.names?.[prevName];
+              }
+            }
+          }
+        }
+        this.decodedMappings.push(mapping);
+      }
+      generatedLine++;
+    }
+  }
+  getOriginalPosition(line, column) {
+    if (!this.initialized || this.decodedMappings.length === 0) return null;
+    let best = null;
+    let bestDistance = Infinity;
+    for (const m of this.decodedMappings) {
+      if (m.generatedLine === line) {
+        const distance = column !== void 0 ? Math.abs(m.generatedColumn - column) : 0;
+        if (distance < bestDistance) {
+          bestDistance = distance;
+          best = m;
+        }
+      } else if (m.generatedLine < line) {
+        if (!best || m.generatedLine > best.generatedLine) best = m;
+      }
+    }
+    if (best && this.sourceMap.sources?.[best.sourceIndex]) {
+      return {
+        source: this.sourceMap.sources[best.sourceIndex],
+        line: best.originalLine,
+        column: best.originalColumn,
+        content: this.sourceMap.sourcesContent?.[best.sourceIndex],
+        name: best.name
+      };
+    }
+    return null;
+  }
+  debug(...args) {
+    try {
+      const err = new Error();
+      const stack = err.stack || "";
+      const stackLines = stack.split("\n");
+      const output = [];
+      output.push(`${COLOR.yellow}━━━━━━━━━━━━━━━━━━━━━━${COLOR.reset}`);
+      output.push(`${COLOR.bold}${COLOR.cyan}📍 DEBUG${COLOR.reset}`);
+      let position = null;
+      for (let i = 2; i < Math.min(stackLines.length, 8); i++) {
+        const line = stackLines[i];
+        console.log(JSON.stringify(line));
+        const match = /(?:\()?(?:[A-Za-z0-9._/-]+):(\d+)(?::(\d+))?\)?$/.exec(line);
+        if (match) {
+          const lineNum = parseInt(match[1]);
+          const colNum = match[2] ? parseInt(match[2]) : void 0;
+          position = this.getOriginalPosition(lineNum, colNum);
+          if (position) break;
+        }
+      }
+      if (position) {
+        const file = position.source.replace(/^.*\//, "");
+        output.push(`${COLOR.blue}📄 ${file}:${position.line}:${position.column}${COLOR.reset}`);
+        if (position.name) output.push(`${COLOR.cyan}🏷 ${position.name}${COLOR.reset}`);
+        if (position.content) {
+          const lines = position.content.split("\n");
+          const target = position.line - 1;
+          const range = 2;
+          output.push(`${COLOR.gray}─────────────────────${COLOR.reset}`);
+          for (let i = Math.max(0, target - range); i <= Math.min(lines.length - 1, target + range); i++) {
+            const num = `${(i + 1).toString().padStart(3, " ")}`;
+            const content = lines[i];
+            if (i === target) {
+              output.push(`${COLOR.red}${COLOR.bold}→ ${num}: ${COLOR.white}${content}${COLOR.reset}`);
+            } else {
+              output.push(`${COLOR.gray}  ${num}: ${content}${COLOR.reset}`);
+            }
+          }
+        }
+      } else {
+        output.push(`${COLOR.gray}📍 Location: (source map not available)${COLOR.reset}`);
+      }
+      output.push(`${COLOR.gray}─────────────────────${COLOR.reset}`);
+      output.push(`${COLOR.bold}${COLOR.white}💾 Values:${COLOR.reset}`);
+      args.forEach((arg, i) => {
+        let val;
+        if (arg === void 0) val = "undefined";
+        else if (arg === null) val = "null";
+        else if (typeof arg === "object") {
+          try {
+            val = JSON.stringify(arg, null, 2);
+          } catch {
+            val = "[Circular or Complex Object]";
+          }
+        } else if (typeof arg === "function") {
+          val = `[Function: ${arg.name || "anonymous"}]`;
+        } else {
+          val = String(arg);
+        }
+        output.push(`${COLOR.green}[${i}]:${COLOR.reset} ${val}`);
+      });
+      output.push(`${COLOR.yellow}━━━━━━━━━━━━━━━━━━━━━━${COLOR.reset}`);
+      console.log(output.join("\n"));
+    } catch (err) {
+      console.log(`${COLOR.red}[DEBUG ERROR]${COLOR.reset}`, err);
+      console.log(args);
+    }
+  }
+}
+const debuggerInstance = new SourceMapDebugger();
+function debug(...args) {
+  debuggerInstance.debug(...args);
+}
+const _TimerScheduler = class _TimerScheduler {
+  /** スケジューラにタスクを登録 */
+  static addTask(task) {
+    this.tasks.add(task);
+    this.ensureStarted();
+  }
+  /** タスクを削除 */
+  static removeTask(task) {
+    this.tasks.delete(task);
+  }
+  /** Interval を開始（1 本だけ） */
+  static ensureStarted() {
+    if (this.started) return;
+    this.started = true;
+    system.runInterval(() => {
+      this.tick++;
+      for (const task of this.tasks) {
+        try {
+          task();
+        } catch (e) {
+          console.error("[TimerScheduler] Task error:", e);
+        }
+      }
+    }, 1);
+  }
+};
+_TimerScheduler.tasks = /* @__PURE__ */ new Set();
+_TimerScheduler.tick = 0;
+_TimerScheduler.started = false;
+let TimerScheduler = _TimerScheduler;
+class Timer {
+  constructor(onRun, onCancel) {
+    this.currentTick = 0;
+    this.stopped = false;
+    this.canceled = false;
+    this.forceCanceled = false;
+    this.onRun = onRun;
+    this.onCancel = onCancel;
+  }
+  /** 一時停止 */
+  stop() {
+    this.stopped = true;
+  }
+  /** 再開 */
+  resume() {
+    this.stopped = false;
+  }
+  /** 停止しているか */
+  isStopped() {
+    return this.stopped;
+  }
+  /** キャンセル要求 */
+  cancel(force = false) {
+    if (force) this.forceCanceled = true;
+    this.canceled = true;
+  }
+  /** タイマー内部キャンセル */
+  internalCancel(force = false) {
+    if (!this.task) return 2;
+    TimerScheduler.removeTask(this.task);
+    this.onCancel?.();
+    return force ? 1 : 0;
+  }
+}
+class RepeatingTimer extends Timer {
+  constructor(onRun, opts = {}, onCancel) {
+    super(onRun, onCancel);
+    this.period = opts.period ?? 1;
+    this.endless = opts.endless ?? true;
+    this.silenceOnStop = opts.silenceOnStop ?? true;
+    this.maxElapsedTicks = opts.maxElapsedTicks;
+    this.onFinal = opts.onFinal;
+  }
+  /** タイマー開始 */
+  start() {
+    this.task = () => {
+      if (this.forceCanceled) return this.internalCancel(true);
+      if (this.canceled) return this.internalCancel();
+      if (!this.endless && this.maxElapsedTicks !== void 0 && this.currentTick >= this.maxElapsedTicks) {
+        this.onFinal?.();
+        return this.internalCancel();
+      }
+      if (this.currentTick % this.period === 0) {
+        if (!this.stopped || this.stopped && !this.silenceOnStop)
+          this.onRun?.(this.currentTick);
+      }
+      if (!this.stopped) this.currentTick++;
+    };
+    TimerScheduler.addTask(this.task);
+  }
+}
+class DelayedTimer extends Timer {
+  constructor(onRun, opts = {}, onCancel) {
+    super(onRun, onCancel);
+    this.delay = opts.delay ?? 1;
+  }
+  start() {
+    this.task = () => {
+      if (this.forceCanceled) return this.internalCancel(true);
+      if (this.canceled) return this.internalCancel();
+      if (this.currentTick >= this.delay) {
+        this.onRun?.(this.currentTick);
+        return this.internalCancel();
+      }
+      this.currentTick++;
+    };
+    TimerScheduler.addTask(this.task);
+  }
+}
+function repeating(opts) {
+  const options = {
+    period: opts.every,
+    endless: opts.endless,
+    silenceOnStop: opts.silenceWhenStopped,
+    maxElapsedTicks: opts.max,
+    onFinal: opts.final
+  };
+  const t = new RepeatingTimer(opts.run, options, opts.cancel);
+  t.start();
+  return t;
+}
+function delayed(ticks, run, cancel) {
+  const t = new DelayedTimer(() => run(), { delay: ticks }, cancel);
+  t.start();
+  return t;
+}
+function sleep(tick) {
+  return new Promise((resolve) => {
+    new DelayedTimer(() => resolve(), { delay: tick }).start();
+  });
+}
+export {
+  DelayedTimer,
+  EventManager,
+  Priority,
+  RepeatingTimer,
+  Vector3,
+  debug,
+  delayed,
+  keystone,
+  repeating,
+  sleep
+};

package/dist/vite-plugin/index.d.ts

@@ -0,0 +1,11 @@
+import { Plugin } from 'vite';
+type PluginConfig = {
+    name: string;
+    uuid?: string;
+    description?: string;
+    authors?: string[];
+    version?: number[];
+    embedSourceMap?: boolean;
+};
+declare const behaviorPacker: ({ name, uuid, description, authors, version, embedSourceMap, }?: PluginConfig) => Plugin;
+export default behaviorPacker;

package/dist/vite-plugin/index.js

@@ -0,0 +1,120 @@
+import { resolve } from "path";
+import * as crypto from "node:crypto";
+import * as fs from "node:fs";
+const behaviorPacker = ({
+  name = "my first plugin",
+  uuid,
+  description = "",
+  authors = [],
+  version = [1, 0, 0],
+  embedSourceMap = true
+} = {
+  name: "my first plugin",
+  description: "",
+  authors: [],
+  version: [1, 0, 0],
+  embedSourceMap: true
+}) => ({
+  name: "BehaviorPacker",
+  config: (config) => {
+    return {
+      ...config,
+      build: {
+        sourcemap: true,
+        minify: false,
+        outDir: "./dist_behavior_pack/scripts",
+        emptyOutDir: true,
+        assetsDir: "",
+        rollupOptions: {
+          external: [
+            "@minecraft/server",
+            "@minecraft/server-net",
+            "@minecraft/server-ui"
+          ],
+          input: {
+            index: resolve(process.cwd(), "./src/index.ts")
+          }
+        }
+      }
+    };
+  },
+  generateBundle(options, bundle) {
+    if (!embedSourceMap) return;
+    for (const [fileName, file] of Object.entries(bundle)) {
+      if (file.type === "chunk" && file.map) {
+        const sourceMapData = file.map;
+        const embeddedSourceMap = {
+          version: sourceMapData.version,
+          sources: sourceMapData.sources,
+          sourcesContent: sourceMapData.sourcesContent,
+          mappings: sourceMapData.mappings,
+          names: sourceMapData.names
+        };
+        const sourceMapEmbed = `// ========== Embedded Source Map ==========
+globalThis.__SOURCE_MAP__ = ${JSON.stringify(embeddedSourceMap)};
+// ========== End of Embedded Source Map ==========
+
+`;
+        const originalCode = file.code;
+        const modifiedCode = sourceMapEmbed + originalCode;
+        file.code = modifiedCode.replace(/\/\/# sourceMappingURL=.+$/gm, "");
+        file.map = null;
+      }
+    }
+    for (const fileName in bundle) {
+      if (fileName.endsWith(".map")) {
+        delete bundle[fileName];
+      }
+    }
+  },
+  writeBundle: async (_options, bundle) => {
+    const entryFile = Object.values(bundle).find(
+      (file) => file.type === "chunk" && file.isEntry
+    );
+    if (!entryFile || entryFile.type !== "chunk") {
+      throw new Error("No entry file found");
+    }
+    const behaviorUUID = uuid ?? crypto.randomUUID();
+    const manifestStub = {
+      "format_version": 2,
+      "header": {
+        "name": name,
+        "description": description,
+        "uuid": behaviorUUID,
+        "version": version,
+        "min_engine_version": [1, 21, 120]
+      },
+      "modules": [
+        {
+          "description": "script",
+          "type": "script",
+          "language": "javascript",
+          "uuid": crypto.randomUUID(),
+          "version": [1, 0, 0],
+          "entry": `scripts/${entryFile.fileName}`
+        }
+      ],
+      "dependencies": [
+        {
+          "module_name": "@minecraft/server",
+          "version": "beta"
+        },
+        {
+          "module_name": "@minecraft/server-ui",
+          "version": "beta"
+        },
+        {
+          "module_name": "@minecraft/server-net",
+          "version": "beta"
+        }
+      ],
+      "metadata": {
+        "authors": authors
+      }
+    };
+    fs.writeFileSync("./dist_behavior_pack/manifest.json", JSON.stringify(manifestStub, null, 2));
+  }
+});
+export {
+  behaviorPacker as default
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "keystonemc",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "ScriptAPI Wrapper",
   "type": "module",
   "scripts": {