koishipro-core.js 1.0.2

package/dist/index.cjs

@@ -0,0 +1,2445 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  CardDataStruct: () => CardDataStruct,
+  LEN_EMPTY: () => LEN_EMPTY,
+  LEN_FAIL: () => LEN_FAIL,
+  LEN_HEADER: () => LEN_HEADER,
+  MESSAGE_BUFFER_SIZE: () => MESSAGE_BUFFER_SIZE,
+  MapReader: () => MapReader,
+  OcgcoreCommonConstants: () => OcgcoreCommonConstants,
+  OcgcoreDuel: () => OcgcoreDuel,
+  OcgcoreDuelOptionFlag: () => OcgcoreDuelOptionFlag,
+  OcgcoreDuelRule: () => OcgcoreDuelRule,
+  OcgcoreMessageType: () => OcgcoreMessageType,
+  OcgcoreScriptConstants: () => OcgcoreScriptConstants,
+  OcgcoreWrapper: () => OcgcoreWrapper,
+  QUERY_BUFFER_SIZE: () => QUERY_BUFFER_SIZE,
+  REGISTRY_BUFFER_SIZE: () => REGISTRY_BUFFER_SIZE,
+  ZipReader: () => ZipReader,
+  createOcgcoreWrapper: () => createOcgcoreWrapper,
+  createSqljsCardReader: () => createSqljsCardReader,
+  encodeUtf8: () => encodeUtf8,
+  normalizeStartDuelOptions: () => normalizeStartDuelOptions,
+  parseCardQuery: () => parseCardQuery,
+  parseFieldCardQuery: () => parseFieldCardQuery,
+  parseFieldInfo: () => parseFieldInfo,
+  parseRegistryDump: () => parseRegistryDump,
+  parseRegistryKeys: () => parseRegistryKeys,
+  playYrp: () => playYrp,
+  readI32: () => readI32,
+  readU16: () => readU16,
+  readU32: () => readU32,
+  readU8: () => readU8
+});
+module.exports = __toCommonJS(index_exports);
+var import_buffer = require("buffer");
+
+// src/vendor/ocgcore-constants.ts
+var OcgcoreCommonConstants = {
+  ACTIVITY_ATTACK: 5,
+  ACTIVITY_BATTLE_PHASE: 6,
+  ACTIVITY_CHAIN: 7,
+  ACTIVITY_FLIPSUMMON: 4,
+  ACTIVITY_NORMALSUMMON: 2,
+  ACTIVITY_SPSUMMON: 3,
+  ACTIVITY_SUMMON: 1,
+  ATTRIBUTES_COUNT: 7,
+  ATTRIBUTE_ALL: 127,
+  ATTRIBUTE_DARK: 32,
+  ATTRIBUTE_DEVINE: 64,
+  ATTRIBUTE_EARTH: 1,
+  ATTRIBUTE_FIRE: 4,
+  ATTRIBUTE_LIGHT: 16,
+  ATTRIBUTE_WATER: 2,
+  ATTRIBUTE_WIND: 8,
+  CARDDATA_ALIAS: 2,
+  CARDDATA_ATTACK: 8,
+  CARDDATA_ATTRIBUTE: 6,
+  CARDDATA_CODE: 1,
+  CARDDATA_DEFENSE: 9,
+  CARDDATA_LEVEL: 5,
+  CARDDATA_LINK_MARKER: 12,
+  CARDDATA_LSCALE: 10,
+  CARDDATA_RACE: 7,
+  CARDDATA_RSCALE: 11,
+  CARDDATA_SETCODE: 3,
+  CARDDATA_TYPE: 4,
+  CHINT_ATTRIBUTE: 4,
+  CHINT_CARD: 2,
+  CHINT_DESC_ADD: 6,
+  CHINT_DESC_REMOVE: 7,
+  CHINT_NUMBER: 5,
+  CHINT_RACE: 3,
+  CHINT_TURN: 1,
+  CURRENT_RULE: 5,
+  DUEL_ATTACK_FIRST_TURN: 2,
+  DUEL_OBSOLETE_RULING: 8,
+  DUEL_PSEUDO_SHUFFLE: 16,
+  DUEL_RETURN_DECK_TOP: 128,
+  DUEL_REVEAL_DECK_SEQ: 256,
+  DUEL_SIMPLE_AI: 64,
+  DUEL_TAG_MODE: 32,
+  DUEL_TEST_MODE: 1,
+  EDESC_OPERATION: 1,
+  EDESC_RESET: 2,
+  FALSE: 0,
+  GETEFFECT_ALL: 15,
+  GETEFFECT_COPY: 4,
+  GETEFFECT_GAIN: 2,
+  GETEFFECT_GRANT: 8,
+  GETEFFECT_INITIAL: 1,
+  HINT_ATTRIB: 7,
+  HINT_CARD: 10,
+  HINT_CODE: 8,
+  HINT_EFFECT: 5,
+  HINT_EVENT: 1,
+  HINT_MESSAGE: 2,
+  HINT_MUSIC: 21,
+  HINT_MUSIC_OGG: 23,
+  HINT_NUMBER: 9,
+  HINT_OPSELECTED: 4,
+  HINT_RACE: 6,
+  HINT_SELECTMSG: 3,
+  HINT_SOUND: 22,
+  HINT_ZONE: 11,
+  LINK_MARKER_BOTTOM: 2,
+  LINK_MARKER_BOTTOM_LEFT: 1,
+  LINK_MARKER_BOTTOM_RIGHT: 4,
+  LINK_MARKER_LEFT: 8,
+  LINK_MARKER_RIGHT: 32,
+  LINK_MARKER_TOP: 128,
+  LINK_MARKER_TOP_LEFT: 64,
+  LINK_MARKER_TOP_RIGHT: 256,
+  LOCATION_DECKBOT: 65537,
+  LOCATION_DECKSHF: 131073,
+  MASTER_RULE3: 3,
+  MASTER_RULE_2020: 5,
+  MSG_ADD_COUNTER: 101,
+  MSG_AI_NAME: 163,
+  MSG_ANNOUNCE_ATTRIB: 141,
+  MSG_ANNOUNCE_CARD: 142,
+  MSG_ANNOUNCE_NUMBER: 143,
+  MSG_ANNOUNCE_RACE: 140,
+  MSG_ATTACK: 110,
+  MSG_ATTACK_DISABLED: 112,
+  MSG_BATTLE: 111,
+  MSG_BECOME_TARGET: 83,
+  MSG_CANCEL_TARGET: 97,
+  MSG_CARD_HINT: 160,
+  MSG_CARD_TARGET: 96,
+  MSG_CHAINED: 71,
+  MSG_CHAINING: 70,
+  MSG_CHAIN_DISABLED: 76,
+  MSG_CHAIN_END: 74,
+  MSG_CHAIN_NEGATED: 75,
+  MSG_CHAIN_SOLVED: 73,
+  MSG_CHAIN_SOLVING: 72,
+  MSG_CONFIRM_CARDS: 31,
+  MSG_CONFIRM_DECKTOP: 30,
+  MSG_CONFIRM_EXTRATOP: 42,
+  MSG_CUSTOM_MSG: 180,
+  MSG_DAMAGE: 91,
+  MSG_DAMAGE_STEP_END: 114,
+  MSG_DAMAGE_STEP_START: 113,
+  MSG_DECK_TOP: 38,
+  MSG_DRAW: 90,
+  MSG_EQUIP: 93,
+  MSG_FIELD_DISABLED: 56,
+  MSG_FLIPSUMMONED: 65,
+  MSG_FLIPSUMMONING: 64,
+  MSG_HAND_RES: 133,
+  MSG_HINT: 2,
+  MSG_LPUPDATE: 94,
+  MSG_MATCH_KILL: 170,
+  MSG_MISSED_EFFECT: 120,
+  MSG_MOVE: 50,
+  MSG_NEW_PHASE: 41,
+  MSG_NEW_TURN: 40,
+  MSG_PAY_LPCOST: 100,
+  MSG_PLAYER_HINT: 165,
+  MSG_POS_CHANGE: 53,
+  MSG_RANDOM_SELECTED: 81,
+  MSG_RECOVER: 92,
+  MSG_RELOAD_FIELD: 162,
+  MSG_REMOVE_COUNTER: 102,
+  MSG_RESET_TIME: 221,
+  MSG_RETRY: 1,
+  MSG_REVERSE_DECK: 37,
+  MSG_ROCK_PAPER_SCISSORS: 132,
+  MSG_SELECT_BATTLECMD: 10,
+  MSG_SELECT_CARD: 15,
+  MSG_SELECT_CHAIN: 16,
+  MSG_SELECT_COUNTER: 22,
+  MSG_SELECT_DISFIELD: 24,
+  MSG_SELECT_EFFECTYN: 12,
+  MSG_SELECT_IDLECMD: 11,
+  MSG_SELECT_OPTION: 14,
+  MSG_SELECT_PLACE: 18,
+  MSG_SELECT_POSITION: 19,
+  MSG_SELECT_SUM: 23,
+  MSG_SELECT_TRIBUTE: 20,
+  MSG_SELECT_UNSELECT_CARD: 26,
+  MSG_SELECT_YESNO: 13,
+  MSG_SET: 54,
+  MSG_SHOW_HINT: 164,
+  MSG_SHUFFLE_DECK: 32,
+  MSG_SHUFFLE_EXTRA: 39,
+  MSG_SHUFFLE_HAND: 33,
+  MSG_SHUFFLE_SET_CARD: 36,
+  MSG_SORT_CARD: 25,
+  MSG_SPSUMMONED: 63,
+  MSG_SPSUMMONING: 62,
+  MSG_SUMMONED: 61,
+  MSG_SUMMONING: 60,
+  MSG_SWAP: 55,
+  MSG_SWAP_GRAVE_DECK: 35,
+  MSG_TAG_SWAP: 161,
+  MSG_TOSS_COIN: 130,
+  MSG_TOSS_DICE: 131,
+  MSG_UPDATE_CARD: 7,
+  MSG_WIN: 5,
+  NEW_MASTER_RULE: 4,
+  NO_FLIP_EFFECT: 65536,
+  OPCODE_ADD: 1073741824,
+  OPCODE_AND: 1073741828,
+  OPCODE_DIV: 1073741827,
+  OPCODE_ISATTRIBUTE: 1073742084,
+  OPCODE_ISCODE: 1073742080,
+  OPCODE_ISRACE: 1073742083,
+  OPCODE_ISSETCARD: 1073742081,
+  OPCODE_ISTYPE: 1073742082,
+  OPCODE_MUL: 1073741826,
+  OPCODE_NEG: 1073741830,
+  OPCODE_NOT: 1073741831,
+  OPCODE_OR: 1073741829,
+  OPCODE_SUB: 1073741825,
+  OPERATION_CANCELED: -1,
+  OPERATION_FAIL: 0,
+  OPERATION_SUCCESS: 1,
+  PHASE_BATTLE: 128,
+  PHASE_BATTLE_START: 8,
+  PHASE_BATTLE_STEP: 16,
+  PHASE_DAMAGE: 32,
+  PHASE_DAMAGE_CAL: 64,
+  PHASE_DRAW: 1,
+  PHASE_END: 512,
+  PHASE_MAIN1: 4,
+  PHASE_MAIN2: 256,
+  PHASE_STANDBY: 2,
+  PHINT_DESC_ADD: 6,
+  PHINT_DESC_REMOVE: 7,
+  PLAYER_ALL: 3,
+  PLAYER_NONE: 2,
+  PLAYER_SELFDES: 5,
+  POS_ATTACK: 3,
+  POS_DEFENSE: 12,
+  POS_FACEDOWN: 10,
+  POS_FACEDOWN_ATTACK: 2,
+  POS_FACEDOWN_DEFENSE: 8,
+  POS_FACEUP: 5,
+  POS_FACEUP_ATTACK: 1,
+  POS_FACEUP_DEFENSE: 4,
+  PROCESSOR_BUFFER_LEN: 268435455,
+  PROCESSOR_END: 536870912,
+  PROCESSOR_FLAG: 4026531840,
+  PROCESSOR_NONE: 0,
+  PROCESSOR_WAITING: 268435456,
+  QUERY_ALIAS: 4,
+  QUERY_ATTACK: 256,
+  QUERY_ATTRIBUTE: 64,
+  QUERY_BASE_ATTACK: 1024,
+  QUERY_BASE_DEFENSE: 2048,
+  QUERY_CODE: 1,
+  QUERY_COUNTERS: 131072,
+  QUERY_DEFENSE: 512,
+  QUERY_EQUIP_CARD: 16384,
+  QUERY_LEVEL: 16,
+  QUERY_LINK: 8388608,
+  QUERY_LSCALE: 2097152,
+  QUERY_OVERLAY_CARD: 65536,
+  QUERY_OWNER: 262144,
+  QUERY_POSITION: 2,
+  QUERY_RACE: 128,
+  QUERY_RANK: 32,
+  QUERY_REASON: 4096,
+  QUERY_REASON_CARD: 8192,
+  QUERY_RSCALE: 4194304,
+  QUERY_STATUS: 524288,
+  QUERY_TARGET_CARD: 32768,
+  QUERY_TYPE: 8,
+  RACES_COUNT: 26,
+  RACE_ALL: 67108863,
+  RACE_AQUA: 64,
+  RACE_BEAST: 16384,
+  RACE_BEASTWARRIOR: 32768,
+  RACE_CREATORGOD: 4194304,
+  RACE_CYBERSE: 16777216,
+  RACE_DEVINE: 2097152,
+  RACE_DINOSAUR: 65536,
+  RACE_DRAGON: 8192,
+  RACE_FAIRY: 4,
+  RACE_FIEND: 8,
+  RACE_FISH: 131072,
+  RACE_ILLUSION: 33554432,
+  RACE_INSECT: 2048,
+  RACE_MACHINE: 32,
+  RACE_PLANT: 1024,
+  RACE_PSYCHO: 1048576,
+  RACE_PYRO: 128,
+  RACE_REPTILE: 524288,
+  RACE_ROCK: 256,
+  RACE_SEASERPENT: 262144,
+  RACE_SPELLCASTER: 2,
+  RACE_THUNDER: 4096,
+  RACE_WARRIOR: 1,
+  RACE_WINDBEAST: 512,
+  RACE_WYRM: 8388608,
+  RACE_ZOMBIE: 16,
+  REASONS_PROCEDURE: 271056896,
+  REASON_ACTION: 2147483648,
+  REASON_ADJUST: 256,
+  REASON_BATTLE: 32,
+  REASON_COST: 128,
+  REASON_DESTROY: 1,
+  REASON_DISCARD: 16384,
+  REASON_DISSUMMON: 4096,
+  REASON_DRAW: 33554432,
+  REASON_EFFECT: 64,
+  REASON_FLIP: 8192,
+  REASON_FUSION: 262144,
+  REASON_LINK: 268435456,
+  REASON_LOST_OVERLAY: 536870912,
+  REASON_LOST_TARGET: 512,
+  REASON_MAINTENANCE: 1073741824,
+  REASON_MATERIAL: 8,
+  REASON_RDAMAGE: 32768,
+  REASON_REDIRECT: 67108864,
+  REASON_RELEASE: 2,
+  REASON_REPLACE: 16777216,
+  REASON_RETURN: 131072,
+  REASON_REVEAL: 134217728,
+  REASON_RITUAL: 1048576,
+  REASON_RRECOVER: 65536,
+  REASON_RULE: 1024,
+  REASON_SPSUMMON: 2048,
+  REASON_SUMMON: 16,
+  REASON_SYNCHRO: 524288,
+  REASON_TEMPORARY: 4,
+  REASON_XYZ: 2097152,
+  RETURN_TEMP_REMOVE_TO_FIELD: 1,
+  RETURN_TRAP_MONSTER_TO_SZONE: 2,
+  SEQ_DECKBOTTOM: 1,
+  SEQ_DECKSHUFFLE: 2,
+  SEQ_DECKTOP: 0,
+  SIZE_AI_NAME: 128,
+  SIZE_HINT_MSG: 1024,
+  SIZE_MESSAGE_BUFFER: 8192,
+  SIZE_RETURN_VALUE: 512,
+  STATUS_ACTIVATE_DISABLED: 262144,
+  STATUS_ACT_FROM_HAND: 134217728,
+  STATUS_ATTACK_CANCELED: 2097152,
+  STATUS_BATTLE_DESTROYED: 16384,
+  STATUS_BATTLE_RESULT: 64,
+  STATUS_CANNOT_CHANGE_FORM: 256,
+  STATUS_CHAINING: 65536,
+  STATUS_CONTINUOUS_POS: 33554432,
+  STATUS_COPYING_EFFECT: 32768,
+  STATUS_DESTROY_CONFIRMED: 4096,
+  STATUS_DISABLED: 1,
+  STATUS_EFFECT_ENABLED: 1024,
+  STATUS_EFFECT_REPLACED: 524288,
+  STATUS_FLIP_SUMMONING: 1048576,
+  STATUS_FLIP_SUMMON_DISABLED: 2147483648,
+  STATUS_FLIP_SUMMON_TURN: 536870912,
+  STATUS_FORBIDDEN: 67108864,
+  STATUS_INITIALIZING: 4194304,
+  STATUS_JUST_POS: 16777216,
+  STATUS_LEAVE_CONFIRMED: 8192,
+  STATUS_NO_LEVEL: 32,
+  STATUS_OPPO_BATTLE: 268435456,
+  STATUS_PROC_COMPLETE: 8,
+  STATUS_SET_TURN: 16,
+  STATUS_SPSUMMON_STEP: 128,
+  STATUS_SPSUMMON_TURN: 1073741824,
+  STATUS_SUMMONING: 512,
+  STATUS_SUMMON_DISABLED: 131072,
+  STATUS_SUMMON_TURN: 2048,
+  STATUS_TO_DISABLE: 4,
+  STATUS_TO_ENABLE: 2,
+  STATUS_TO_HAND_WITHOUT_CONFIRM: 8388608,
+  TRUE: 1,
+  TYPES_EXTRA_DECK: 75505728,
+  TYPE_CONTINUOUS: 131072,
+  TYPE_COUNTER: 1048576,
+  TYPE_DUAL: 2048,
+  TYPE_EFFECT: 32,
+  TYPE_EQUIP: 262144,
+  TYPE_FIELD: 524288,
+  TYPE_FLIP: 2097152,
+  TYPE_FUSION: 64,
+  TYPE_LINK: 67108864,
+  TYPE_MONSTER: 1,
+  TYPE_NORMAL: 16,
+  TYPE_PENDULUM: 16777216,
+  TYPE_QUICKPLAY: 65536,
+  TYPE_RITUAL: 128,
+  TYPE_SPELL: 2,
+  TYPE_SPIRIT: 512,
+  TYPE_SPSUMMON: 33554432,
+  TYPE_SYNCHRO: 8192,
+  TYPE_TOKEN: 16384,
+  TYPE_TOON: 4194304,
+  TYPE_TRAP: 4,
+  TYPE_TRAPMONSTER: 256,
+  TYPE_TUNER: 4096,
+  TYPE_UNION: 1024,
+  TYPE_XYZ: 8388608
+};
+
+// src/constants/ocgcore.ts
+var MESSAGE_BUFFER_SIZE = OcgcoreCommonConstants.SIZE_MESSAGE_BUFFER;
+var QUERY_BUFFER_SIZE = 16384;
+var REGISTRY_BUFFER_SIZE = 8192;
+var LEN_FAIL = 0;
+var LEN_EMPTY = 4;
+var LEN_HEADER = 8;
+
+// src/utility/binary.ts
+function readU8(buf, offset) {
+  return buf[offset] ?? 0;
+}
+function readU16(buf, offset) {
+  return new DataView(buf.buffer, buf.byteOffset, buf.byteLength).getUint16(
+    offset,
+    true
+  );
+}
+function readI32(buf, offset) {
+  return new DataView(buf.buffer, buf.byteOffset, buf.byteLength).getInt32(
+    offset,
+    true
+  );
+}
+function readU32(buf, offset) {
+  return new DataView(buf.buffer, buf.byteOffset, buf.byteLength).getUint32(
+    offset,
+    true
+  );
+}
+
+// src/adapters/ocgcore-parsers.ts
+var decoder = new TextDecoder("utf-8");
+function decodeUtf8(value) {
+  return decoder.decode(value);
+}
+function parseCardInfo(payload) {
+  let offset = 0;
+  const flags = readI32(payload, offset) >>> 0;
+  offset += 4;
+  const info = { flags, empty: flags === 0 };
+  if (flags === 0) {
+    return info;
+  }
+  if (flags & OcgcoreCommonConstants.QUERY_CODE) {
+    info.code = readI32(payload, offset);
+    offset += 4;
+  }
+  if (flags & OcgcoreCommonConstants.QUERY_POSITION) {
+    const pdata = readI32(payload, offset);
+    offset += 4;
+    info.position = (pdata >>> 24 & 255) >>> 0;
+  }
+  if (flags & OcgcoreCommonConstants.QUERY_ALIAS) {
+    info.alias = readI32(payload, offset);
+    offset += 4;
+  }
+  if (flags & OcgcoreCommonConstants.QUERY_TYPE) {
+    info.type = readI32(payload, offset);
+    offset += 4;
+  }
+  if (flags & OcgcoreCommonConstants.QUERY_LEVEL) {
+    info.level = readI32(payload, offset);
+    offset += 4;
+  }
+  if (flags & OcgcoreCommonConstants.QUERY_RANK) {
+    info.rank = readI32(payload, offset);
+    offset += 4;
+  }
+  if (flags & OcgcoreCommonConstants.QUERY_ATTRIBUTE) {
+    info.attribute = readI32(payload, offset);
+    offset += 4;
+  }
+  if (flags & OcgcoreCommonConstants.QUERY_RACE) {
+    info.race = readI32(payload, offset);
+    offset += 4;
+  }
+  if (flags & OcgcoreCommonConstants.QUERY_ATTACK) {
+    info.attack = readI32(payload, offset);
+    offset += 4;
+  }
+  if (flags & OcgcoreCommonConstants.QUERY_DEFENSE) {
+    info.defense = readI32(payload, offset);
+    offset += 4;
+  }
+  if (flags & OcgcoreCommonConstants.QUERY_BASE_ATTACK) {
+    info.baseAttack = readI32(payload, offset);
+    offset += 4;
+  }
+  if (flags & OcgcoreCommonConstants.QUERY_BASE_DEFENSE) {
+    info.baseDefense = readI32(payload, offset);
+    offset += 4;
+  }
+  if (flags & OcgcoreCommonConstants.QUERY_REASON) {
+    info.reason = readI32(payload, offset);
+    offset += 4;
+  }
+  if (flags & OcgcoreCommonConstants.QUERY_REASON_CARD) {
+    offset += 4;
+  }
+  if (flags & OcgcoreCommonConstants.QUERY_EQUIP_CARD) {
+    const controller = readU8(payload, offset) >>> 0;
+    const location = readU8(payload, offset + 1) >>> 0;
+    const sequence = readU8(payload, offset + 2) >>> 0;
+    info.equipCard = { controller, location, sequence };
+    offset += 4;
+  }
+  if (flags & OcgcoreCommonConstants.QUERY_TARGET_CARD) {
+    const count = readI32(payload, offset);
+    offset += 4;
+    const targets = [];
+    for (let i = 0; i < count; i++) {
+      const controller = readU8(payload, offset) >>> 0;
+      const location = readU8(payload, offset + 1) >>> 0;
+      const sequence = readU8(payload, offset + 2) >>> 0;
+      targets.push({ controller, location, sequence });
+      offset += 4;
+    }
+    info.targetCards = targets;
+  }
+  if (flags & OcgcoreCommonConstants.QUERY_OVERLAY_CARD) {
+    const count = readI32(payload, offset);
+    offset += 4;
+    const overlay = [];
+    for (let i = 0; i < count; i++) {
+      overlay.push(readI32(payload, offset));
+      offset += 4;
+    }
+    info.overlayCards = overlay;
+  }
+  if (flags & OcgcoreCommonConstants.QUERY_COUNTERS) {
+    const count = readI32(payload, offset);
+    offset += 4;
+    const counters = [];
+    for (let i = 0; i < count; i++) {
+      const type = readU16(payload, offset) >>> 0;
+      const ccount = readU16(payload, offset + 2) >>> 0;
+      counters.push({ type, count: ccount });
+      offset += 4;
+    }
+    info.counters = counters;
+  }
+  if (flags & OcgcoreCommonConstants.QUERY_OWNER) {
+    info.owner = readI32(payload, offset);
+    offset += 4;
+  }
+  if (flags & OcgcoreCommonConstants.QUERY_STATUS) {
+    info.status = readI32(payload, offset);
+    offset += 4;
+  }
+  if (flags & OcgcoreCommonConstants.QUERY_LSCALE) {
+    info.lscale = readI32(payload, offset);
+    offset += 4;
+  }
+  if (flags & OcgcoreCommonConstants.QUERY_RSCALE) {
+    info.rscale = readI32(payload, offset);
+    offset += 4;
+  }
+  if (flags & OcgcoreCommonConstants.QUERY_LINK) {
+    info.link = readI32(payload, offset);
+    offset += 4;
+    info.linkMarker = readI32(payload, offset);
+    offset += 4;
+  }
+  return info;
+}
+function parseCardQuery(raw, length) {
+  if (length <= LEN_HEADER) {
+    return null;
+  }
+  const payload = raw.subarray(4, length);
+  return parseCardInfo(payload);
+}
+function parseFieldCardQuery(raw, length) {
+  const cards = [];
+  let offset = 0;
+  while (offset + 4 <= length) {
+    const chunkLen = readI32(raw, offset);
+    if (chunkLen <= 0) {
+      break;
+    }
+    const end = Math.min(length, offset + chunkLen);
+    if (chunkLen <= LEN_HEADER) {
+      cards.push({ flags: 0, empty: true });
+    } else {
+      const payload = raw.subarray(offset + 4, end);
+      cards.push(parseCardInfo(payload));
+    }
+    offset += chunkLen;
+  }
+  return cards;
+}
+function parseFieldInfo(raw) {
+  let offset = 0;
+  const message = readU8(raw, offset++) >>> 0;
+  const duelRule = readU8(raw, offset++) >>> 0;
+  const players = [];
+  for (let i = 0; i < 2; i++) {
+    const lp = readI32(raw, offset) >>> 0;
+    offset += 4;
+    const mzone = [];
+    for (let seq = 0; seq < 7; seq++) {
+      const occupied = readU8(raw, offset++) >>> 0 !== 0;
+      if (occupied) {
+        const position = readU8(raw, offset++) >>> 0;
+        const xyzCount = readU8(raw, offset++) >>> 0;
+        mzone.push({ occupied, position, xyzCount });
+      } else {
+        mzone.push({ occupied });
+      }
+    }
+    const szone = [];
+    for (let seq = 0; seq < 8; seq++) {
+      const occupied = readU8(raw, offset++) >>> 0 !== 0;
+      if (occupied) {
+        const position = readU8(raw, offset++) >>> 0;
+        szone.push({ occupied, position });
+      } else {
+        szone.push({ occupied });
+      }
+    }
+    const deckCount = readU8(raw, offset++) >>> 0;
+    const handCount = readU8(raw, offset++) >>> 0;
+    const graveCount = readU8(raw, offset++) >>> 0;
+    const removedCount = readU8(raw, offset++) >>> 0;
+    const extraCount = readU8(raw, offset++) >>> 0;
+    const extraPCount = readU8(raw, offset++) >>> 0;
+    players[i] = {
+      lp,
+      mzone,
+      szone,
+      deckCount,
+      handCount,
+      graveCount,
+      removedCount,
+      extraCount,
+      extraPCount
+    };
+  }
+  const chainCount = readU8(raw, offset++) >>> 0;
+  const chains = [];
+  for (let i = 0; i < chainCount; i++) {
+    const code = readU32(raw, offset) >>> 0;
+    offset += 4;
+    const infoLocation = readU32(raw, offset) >>> 0;
+    offset += 4;
+    const chainCard = {
+      controller: (infoLocation & 255) >>> 0,
+      location: (infoLocation >>> 8 & 255) >>> 0,
+      sequence: (infoLocation >>> 16 & 255) >>> 0,
+      subSequence: (infoLocation >>> 24 & 255) >>> 0
+    };
+    const trigger = {
+      controller: readU8(raw, offset++) >>> 0,
+      location: readU8(raw, offset++) >>> 0,
+      sequence: readU8(raw, offset++) >>> 0
+    };
+    const description = readU32(raw, offset) >>> 0;
+    offset += 4;
+    chains.push({ code, chainCard, trigger, description });
+  }
+  return { message, duelRule, players, chains };
+}
+function parseRegistryKeys(raw) {
+  const keys = [];
+  let offset = 0;
+  while (offset + 2 <= raw.length) {
+    const len = readU16(raw, offset);
+    offset += 2;
+    if (offset + len > raw.length) {
+      break;
+    }
+    const keyBytes = raw.subarray(offset, offset + len);
+    offset += len;
+    keys.push(decodeUtf8(keyBytes));
+  }
+  return keys;
+}
+function parseRegistryDump(raw) {
+  const entries = [];
+  let offset = 0;
+  while (offset + 4 <= raw.length) {
+    const keyLen = readU16(raw, offset);
+    const valLen = readU16(raw, offset + 2);
+    offset += 4;
+    if (offset + keyLen + valLen > raw.length) {
+      break;
+    }
+    const keyBytes = raw.subarray(offset, offset + keyLen);
+    offset += keyLen;
+    const valueBytes = raw.subarray(offset, offset + valLen);
+    offset += valLen;
+    const entry = {
+      key: decodeUtf8(keyBytes),
+      value: valueBytes
+    };
+    entry.valueText = decodeUtf8(valueBytes);
+    entries.push(entry);
+  }
+  return entries;
+}
+
+// src/adapters/start-duel.ts
+function normalizeStartDuelOptions(options) {
+  if (typeof options === "number") {
+    return options;
+  }
+  const duelRule = options.rule ?? 0;
+  let duelOptions = options.options ?? 0;
+  if (options.flags?.length) {
+    for (const flag of options.flags) {
+      duelOptions = (duelOptions | flag) >>> 0;
+    }
+  }
+  return ((duelRule & 65535) << 16 | duelOptions & 65535) >>> 0;
+}
+
+// src/utility/utf8.ts
+var encoder = new TextEncoder();
+var decoder2 = new TextDecoder("utf-8");
+function encodeUtf8(value) {
+  return encoder.encode(value);
+}
+
+// src/ocgcore-duel.ts
+var OcgcoreDuel = class {
+  constructor(ocgcoreWrapper, duelPtr) {
+    this.ocgcoreWrapper = ocgcoreWrapper;
+    this.duelPtr = duelPtr;
+    this.returnPtr = 0;
+    this.returnSize = 512;
+  }
+  startDuel(options) {
+    if (!this.returnPtr) {
+      this.returnPtr = this.ocgcoreWrapper.malloc(this.returnSize);
+    }
+    const optionValue = normalizeStartDuelOptions(options);
+    this.ocgcoreWrapper.ocgcoreModule._start_duel(this.duelPtr, optionValue);
+  }
+  endDuel() {
+    this.ocgcoreWrapper.ocgcoreModule._end_duel(this.duelPtr);
+    if (this.returnPtr) {
+      this.ocgcoreWrapper.free(this.returnPtr);
+      this.returnPtr = 0;
+    }
+    this.ocgcoreWrapper.forgetDuel(this.duelPtr);
+  }
+  setPlayerInfo(info) {
+    this.ocgcoreWrapper.ocgcoreModule._set_player_info(
+      this.duelPtr,
+      info.playerId,
+      info.lp,
+      info.startCount,
+      info.drawCount
+    );
+  }
+  _getLogMessage(bufPtr) {
+    return this.ocgcoreWrapper.ocgcoreModule._get_log_message(
+      this.duelPtr,
+      bufPtr
+    );
+  }
+  getMessage(length) {
+    const ptr = this.ocgcoreWrapper.malloc(MESSAGE_BUFFER_SIZE);
+    this.ocgcoreWrapper.ocgcoreModule._get_message(this.duelPtr, ptr);
+    const raw = this.ocgcoreWrapper.copyHeap(ptr, length);
+    this.ocgcoreWrapper.free(ptr);
+    return { length, raw };
+  }
+  process() {
+    const result = this.ocgcoreWrapper.ocgcoreModule._process(this.duelPtr);
+    const length = (result & 268435455) >>> 0;
+    const status = (result >>> 28 & 15) >>> 0;
+    const message = this.getMessage(length);
+    return { length: message.length, raw: message.raw, status };
+  }
+  newCard(card) {
+    this.ocgcoreWrapper.ocgcoreModule._new_card(
+      this.duelPtr,
+      card.code,
+      card.owner,
+      card.playerId,
+      card.location,
+      card.sequence,
+      card.position
+    );
+  }
+  newTagCard(card) {
+    this.ocgcoreWrapper.ocgcoreModule._new_tag_card(
+      this.duelPtr,
+      card.code,
+      card.owner,
+      card.location
+    );
+  }
+  queryCard(query) {
+    const ptr = this.ocgcoreWrapper.malloc(QUERY_BUFFER_SIZE);
+    const length = this.ocgcoreWrapper.ocgcoreModule._query_card(
+      this.duelPtr,
+      query.playerId,
+      query.location,
+      query.sequence,
+      query.queryFlag,
+      ptr,
+      query.useCache ?? 0
+    );
+    const raw = this.ocgcoreWrapper.copyHeap(ptr, length);
+    this.ocgcoreWrapper.free(ptr);
+    const card = length <= LEN_HEADER ? null : parseCardQuery(raw, length);
+    return { length, raw, card };
+  }
+  queryFieldCount(query) {
+    return this.ocgcoreWrapper.ocgcoreModule._query_field_count(
+      this.duelPtr,
+      query.playerId,
+      query.location
+    );
+  }
+  queryFieldCard(query) {
+    const ptr = this.ocgcoreWrapper.malloc(QUERY_BUFFER_SIZE);
+    const length = this.ocgcoreWrapper.ocgcoreModule._query_field_card(
+      this.duelPtr,
+      query.playerId,
+      query.location,
+      query.queryFlag,
+      ptr,
+      query.useCache ?? 0
+    );
+    const raw = this.ocgcoreWrapper.copyHeap(ptr, length);
+    this.ocgcoreWrapper.free(ptr);
+    const cards = parseFieldCardQuery(raw, length);
+    return { length, raw, cards };
+  }
+  queryFieldInfo() {
+    const ptr = this.ocgcoreWrapper.malloc(QUERY_BUFFER_SIZE);
+    const length = this.ocgcoreWrapper.ocgcoreModule._query_field_info(
+      this.duelPtr,
+      ptr
+    );
+    const raw = this.ocgcoreWrapper.copyHeap(ptr, length);
+    this.ocgcoreWrapper.free(ptr);
+    const field = parseFieldInfo(raw);
+    return { length, raw, field };
+  }
+  setResponseInt(value) {
+    this.ocgcoreWrapper.ocgcoreModule._set_responsei(this.duelPtr, value);
+  }
+  setResponse(response) {
+    if (response.length > this.returnSize) {
+      this.ocgcoreWrapper.free(this.returnPtr);
+      this.returnPtr = this.ocgcoreWrapper.malloc(response.length);
+      this.returnSize = response.length;
+    }
+    this.ocgcoreWrapper.setHeap(this.returnPtr, response);
+    this.ocgcoreWrapper.ocgcoreModule._set_responseb(
+      this.duelPtr,
+      this.returnPtr
+    );
+  }
+  preloadScript(scriptPath) {
+    this.ocgcoreWrapper.useTmpData(
+      (ptr) => this.ocgcoreWrapper.ocgcoreModule._preload_script(this.duelPtr, ptr),
+      scriptPath
+    );
+  }
+  getRegistryValue(key) {
+    const keyBytes = encodeUtf8(key);
+    const outPtr = this.ocgcoreWrapper.malloc(REGISTRY_BUFFER_SIZE);
+    const length = this.ocgcoreWrapper.useTmpData(
+      (keyPtr) => this.ocgcoreWrapper.ocgcoreModule._get_registry_value(
+        this.duelPtr,
+        keyPtr,
+        keyBytes.length,
+        outPtr
+      ),
+      key
+    );
+    const raw = this.ocgcoreWrapper.copyHeap(outPtr, Math.max(0, length));
+    this.ocgcoreWrapper.free(outPtr);
+    const value = raw;
+    const text = length >= 0 ? decodeUtf8(raw) : void 0;
+    return { length, raw, value, text };
+  }
+  setRegistryValue(key, value) {
+    const keyBytes = encodeUtf8(key);
+    const valueBytes = encodeUtf8(value);
+    this.ocgcoreWrapper.useTmpData(
+      (keyPtr, valuePtr) => this.ocgcoreWrapper.ocgcoreModule._set_registry_value(
+        this.duelPtr,
+        keyPtr,
+        keyBytes.length,
+        valuePtr,
+        valueBytes.length
+      ),
+      key,
+      value
+    );
+  }
+  getRegistryKeys() {
+    const outPtr = this.ocgcoreWrapper.malloc(REGISTRY_BUFFER_SIZE);
+    const length = this.ocgcoreWrapper.ocgcoreModule._get_registry_keys(
+      this.duelPtr,
+      outPtr
+    );
+    const raw = this.ocgcoreWrapper.copyHeap(outPtr, Math.max(0, length));
+    this.ocgcoreWrapper.free(outPtr);
+    const keys = length >= 0 ? parseRegistryKeys(raw) : [];
+    return { length, raw, keys };
+  }
+  clearRegistry() {
+    this.ocgcoreWrapper.ocgcoreModule._clear_registry(this.duelPtr);
+  }
+  dumpRegistry() {
+    const outPtr = this.ocgcoreWrapper.malloc(REGISTRY_BUFFER_SIZE);
+    const length = this.ocgcoreWrapper.ocgcoreModule._dump_registry(
+      this.duelPtr,
+      outPtr
+    );
+    const raw = this.ocgcoreWrapper.copyHeap(outPtr, Math.max(0, length));
+    this.ocgcoreWrapper.free(outPtr);
+    const entries = length >= 0 ? parseRegistryDump(raw) : [];
+    return { length, raw, entries };
+  }
+  loadRegistry(input) {
+    this.ocgcoreWrapper.useTmpData(
+      (ptr) => this.ocgcoreWrapper.ocgcoreModule._load_registry(
+        this.duelPtr,
+        ptr,
+        input.length
+      ),
+      input
+    );
+  }
+};
+
+// src/structs/card-data.ts
+var import_typed_struct = __toESM(require("typed-struct"));
+var CardDataStruct = new import_typed_struct.default().UInt32LE("code").UInt32LE("alias").UInt16Array("setcode", 16).UInt32LE("type").UInt32LE("level").UInt32LE("attribute").UInt32LE("race").Int32LE("attack").Int32LE("defense").UInt32LE("lscale").UInt32LE("rscale").UInt32LE("linkMarker").compile();
+
+// src/types/ocgcore-enums.ts
+var OcgcoreMessageType = /* @__PURE__ */ ((OcgcoreMessageType2) => {
+  OcgcoreMessageType2["ScriptError"] = "ScriptError";
+  OcgcoreMessageType2["DebugMessage"] = "DebugMessage";
+  return OcgcoreMessageType2;
+})(OcgcoreMessageType || {});
+var OcgcoreDuelRule = /* @__PURE__ */ ((OcgcoreDuelRule2) => {
+  OcgcoreDuelRule2[OcgcoreDuelRule2["Rule1"] = 1] = "Rule1";
+  OcgcoreDuelRule2[OcgcoreDuelRule2["Rule2"] = 2] = "Rule2";
+  OcgcoreDuelRule2[OcgcoreDuelRule2["MasterRule3"] = 3] = "MasterRule3";
+  OcgcoreDuelRule2[OcgcoreDuelRule2["NewMasterRule"] = 4] = "NewMasterRule";
+  OcgcoreDuelRule2[OcgcoreDuelRule2["MasterRule2020"] = 5] = "MasterRule2020";
+  return OcgcoreDuelRule2;
+})(OcgcoreDuelRule || {});
+var OcgcoreDuelOptionFlag = /* @__PURE__ */ ((OcgcoreDuelOptionFlag2) => {
+  OcgcoreDuelOptionFlag2[OcgcoreDuelOptionFlag2["TestMode"] = 1] = "TestMode";
+  OcgcoreDuelOptionFlag2[OcgcoreDuelOptionFlag2["AttackFirstTurn"] = 2] = "AttackFirstTurn";
+  OcgcoreDuelOptionFlag2[OcgcoreDuelOptionFlag2["ObsoleteRuling"] = 8] = "ObsoleteRuling";
+  OcgcoreDuelOptionFlag2[OcgcoreDuelOptionFlag2["PseudoShuffle"] = 16] = "PseudoShuffle";
+  OcgcoreDuelOptionFlag2[OcgcoreDuelOptionFlag2["TagMode"] = 32] = "TagMode";
+  OcgcoreDuelOptionFlag2[OcgcoreDuelOptionFlag2["SimpleAI"] = 64] = "SimpleAI";
+  OcgcoreDuelOptionFlag2[OcgcoreDuelOptionFlag2["ReturnDeckTop"] = 128] = "ReturnDeckTop";
+  OcgcoreDuelOptionFlag2[OcgcoreDuelOptionFlag2["RevealDeckSeq"] = 256] = "RevealDeckSeq";
+  return OcgcoreDuelOptionFlag2;
+})(OcgcoreDuelOptionFlag || {});
+
+// src/ocgcore-wrapper.ts
+var OcgcoreWrapper = class {
+  constructor(ocgcoreModule, options) {
+    this.ocgcoreModule = ocgcoreModule;
+    this.scriptBufferPtr = 0;
+    this.scriptBufferSize = 0;
+    this.logBufferPtr = 0;
+    this.logBufferSize = 0;
+    this.tmpStringBufferPtr = 0;
+    this.tmpStringBufferSize = 0;
+    this.scriptReaderFunc = 0;
+    this.cardReaderFunc = 0;
+    this.messageHandlerFunc = 0;
+    this.encoder = new TextEncoder();
+    this.decoder = new TextDecoder("utf-8");
+    this.duels = /* @__PURE__ */ new Map();
+    this.heapU8 = ocgcoreModule.HEAPU8;
+    this.heapView = new DataView(this.heapU8.buffer);
+    this.scriptBufferSize = options?.scriptBufferSize ?? 1048576;
+    this.logBufferSize = options?.logBufferSize ?? 1024;
+  }
+  getUTF8String(ptr) {
+    let length = 0;
+    while (this.heapU8[ptr + length] !== 0) {
+      length++;
+    }
+    return this.decoder.decode(this.heapU8.subarray(ptr, ptr + length));
+  }
+  setHeap(ptr, data) {
+    this.heapU8.set(data, ptr);
+  }
+  copyHeap(ptr, length) {
+    return this.heapU8.slice(ptr, ptr + length);
+  }
+  useTmpData(cb, ...args) {
+    const encoded = args.map(
+      (item) => typeof item === "string" ? this.encoder.encode(item) : item
+    );
+    const totalLength = encoded.reduce((acc, bytes) => acc + bytes.length + 1, 0);
+    if (totalLength > this.tmpStringBufferSize) {
+      if (this.tmpStringBufferPtr) {
+        this.ocgcoreModule._free(this.tmpStringBufferPtr);
+      }
+      this.tmpStringBufferPtr = this.ocgcoreModule._malloc(totalLength);
+      this.tmpStringBufferSize = totalLength;
+    }
+    let offset = 0;
+    const ptrs = encoded.map((bytes) => {
+      const ptr = this.tmpStringBufferPtr + offset;
+      this.heapU8.set(bytes, ptr);
+      this.heapU8[ptr + bytes.length] = 0;
+      offset += bytes.length + 1;
+      return ptr;
+    });
+    return cb(...ptrs);
+  }
+  createFunction(fn, signature) {
+    return this.ocgcoreModule.addFunction(fn, signature);
+  }
+  addFunction(fn, signature) {
+    return this.ocgcoreModule.addFunction(fn, signature);
+  }
+  removeFunction(index) {
+    this.ocgcoreModule.removeFunction(index);
+  }
+  createDuel(seed) {
+    const duelPtr = this.ocgcoreModule._create_duel(seed);
+    return this.getOrCreateDuel(duelPtr);
+  }
+  createDuelV2(seedSequence) {
+    const count = seedSequence.length;
+    const byteLength = count * 4;
+    const ptr = this.ocgcoreModule._malloc(byteLength);
+    const view = new Uint32Array(this.heapU8.buffer, ptr, count);
+    for (let i = 0; i < count; i++) {
+      view[i] = seedSequence[i] >>> 0;
+    }
+    const duelPtr = this.ocgcoreModule._create_duel_v2(ptr);
+    this.ocgcoreModule._free(ptr);
+    return this.getOrCreateDuel(duelPtr);
+  }
+  defaultScriptReader(namePtr, dataPtr) {
+    return this.ocgcoreModule._default_script_reader(namePtr, dataPtr);
+  }
+  malloc(size) {
+    return this.ocgcoreModule._malloc(size);
+  }
+  free(ptr) {
+    this.ocgcoreModule._free(ptr);
+  }
+  _setScriptReader(funcPtr) {
+    this.ocgcoreModule._set_script_reader(funcPtr);
+  }
+  _setCardReader(funcPtr) {
+    this.ocgcoreModule._set_card_reader(funcPtr);
+  }
+  _setMessageHandler(funcPtr) {
+    this.ocgcoreModule._set_message_handler(funcPtr);
+  }
+  stdioExit() {
+    this.ocgcoreModule.___stdio_exit();
+  }
+  setScriptReader(reader) {
+    if (this.scriptReaderFunc) {
+      this.ocgcoreModule.removeFunction(this.scriptReaderFunc);
+    }
+    if (!this.scriptBufferPtr) {
+      this.scriptBufferPtr = this.ocgcoreModule._malloc(this.scriptBufferSize);
+    }
+    this.scriptReaderFunc = this.createFunction((scriptPtr, lenPtr) => {
+      const scriptPath = this.getUTF8String(scriptPtr);
+      const content = reader(scriptPath);
+      if (content == null) {
+        return 0;
+      }
+      const bytes = typeof content === "string" ? this.encoder.encode(content) : content;
+      if (bytes.length > this.scriptBufferSize) {
+        this.ocgcoreModule._free(this.scriptBufferPtr);
+        this.scriptBufferPtr = this.ocgcoreModule._malloc(bytes.length);
+        this.scriptBufferSize = bytes.length;
+      }
+      this.heapU8.set(bytes, this.scriptBufferPtr);
+      this.heapView.setInt32(lenPtr, bytes.length, true);
+      return this.scriptBufferPtr;
+    }, "iii");
+    this._setScriptReader(this.scriptReaderFunc);
+  }
+  setCardReader(reader) {
+    if (this.cardReaderFunc) {
+      this.ocgcoreModule.removeFunction(this.cardReaderFunc);
+    }
+    this.cardReaderFunc = this.createFunction((cardId, cardDataPtr) => {
+      const data = reader(cardId);
+      if (!data) {
+        return 0;
+      }
+      const CardDataCtor = CardDataStruct;
+      let buf;
+      if (data instanceof CardDataCtor) {
+        buf = CardDataStruct.raw(data);
+      } else {
+        const cardData = new CardDataCtor();
+        cardData.code = data.code;
+        cardData.alias = data.alias;
+        const targetSetcode = cardData.setcode;
+        targetSetcode.fill(0);
+        if (data.setcode instanceof Uint16Array && data.setcode.length === 16) {
+          targetSetcode.set(data.setcode);
+        } else {
+          for (let i = 0; i < 16 && i < data.setcode.length; i++) {
+            targetSetcode[i] = data.setcode[i];
+          }
+        }
+        cardData.type = data.type;
+        cardData.level = data.level;
+        cardData.attribute = data.attribute;
+        cardData.race = data.race;
+        cardData.attack = data.attack;
+        cardData.defense = data.defense;
+        cardData.lscale = data.lscale;
+        cardData.rscale = data.rscale;
+        cardData.linkMarker = data.linkMarker;
+        buf = CardDataStruct.raw(cardData);
+      }
+      this.heapU8.set(buf, cardDataPtr);
+      return 0;
+    }, "iii");
+    this._setCardReader(this.cardReaderFunc);
+  }
+  setMessageHandler(handler) {
+    if (!this.logBufferPtr) {
+      this.logBufferPtr = this.ocgcoreModule._malloc(this.logBufferSize);
+    }
+    if (this.messageHandlerFunc) {
+      this.ocgcoreModule.removeFunction(this.messageHandlerFunc);
+    }
+    this.messageHandlerFunc = this.createFunction((duelPtr, messageType) => {
+      this.ocgcoreModule._get_log_message(duelPtr, this.logBufferPtr);
+      const message = this.getUTF8String(this.logBufferPtr);
+      const type = messageType === 1 ? "ScriptError" /* ScriptError */ : messageType === 2 ? "DebugMessage" /* DebugMessage */ : messageType;
+      handler(this.getOrCreateDuel(duelPtr), message, type);
+    }, "iii");
+    this._setMessageHandler(this.messageHandlerFunc);
+  }
+  getOrCreateDuel(duelPtr) {
+    const existing = this.duels.get(duelPtr);
+    if (existing) {
+      return existing;
+    }
+    const duel = new OcgcoreDuel(this, duelPtr);
+    this.duels.set(duelPtr, duel);
+    return duel;
+  }
+  forgetDuel(duelPtr) {
+    this.duels.delete(duelPtr);
+  }
+  finalize() {
+    if (this.scriptReaderFunc) {
+      this.ocgcoreModule.removeFunction(this.scriptReaderFunc);
+      this.scriptReaderFunc = 0;
+    }
+    if (this.cardReaderFunc) {
+      this.ocgcoreModule.removeFunction(this.cardReaderFunc);
+      this.cardReaderFunc = 0;
+    }
+    if (this.messageHandlerFunc) {
+      this.ocgcoreModule.removeFunction(this.messageHandlerFunc);
+      this.messageHandlerFunc = 0;
+    }
+    if (this.scriptBufferPtr) {
+      this.ocgcoreModule._free(this.scriptBufferPtr);
+      this.scriptBufferPtr = 0;
+      this.scriptBufferSize = 0;
+    }
+    if (this.logBufferPtr) {
+      this.ocgcoreModule._free(this.logBufferPtr);
+      this.logBufferPtr = 0;
+      this.logBufferSize = 0;
+    }
+    if (this.tmpStringBufferPtr) {
+      this.ocgcoreModule._free(this.tmpStringBufferPtr);
+      this.tmpStringBufferPtr = 0;
+      this.tmpStringBufferSize = 0;
+    }
+  }
+};
+
+// src/ocgcore-wrapper-utils.ts
+function normalizeOcgcoreFactory(mod) {
+  const typed = mod;
+  if (typeof typed === "function") {
+    return typed;
+  }
+  if (typed && typeof typed.default === "function") {
+    return typed.default;
+  }
+  throw new Error("Invalid ocgcore factory module");
+}
+
+// src/load-ocgcore-factory.cjs.ts
+async function loadOcgcoreFactory() {
+  const mod = require("./vendor/wasm_cjs/libocgcore.cjs");
+  return normalizeOcgcoreFactory(mod);
+}
+
+// src/create-ocgcore-wrapper.ts
+async function createOcgcoreWrapper(options = {}) {
+  const factory = await loadOcgcoreFactory();
+  const overrides = {
+    ...options.moduleOverrides
+  };
+  if (options.wasmBinary) {
+    overrides.wasmBinary = options.wasmBinary;
+  }
+  if (options.locateFile) {
+    overrides.locateFile = options.locateFile;
+  }
+  const moduleInstance = await factory(overrides);
+  return new OcgcoreWrapper(moduleInstance);
+}
+
+// src/adapters/script-readers.ts
+var import_jszip = __toESM(require("jszip"));
+var SCRIPT_PREFIX = "./script/";
+function normalizePath(input) {
+  let path = input.replace(/\\/g, "/");
+  if (path.startsWith(SCRIPT_PREFIX)) {
+    path = path.slice(SCRIPT_PREFIX.length);
+  }
+  return path;
+}
+function buildCandidates(filename) {
+  const entries = [
+    filename,
+    `specials/${filename}`,
+    `expansions/script/${filename}`,
+    `script/${filename}`
+  ];
+  const candidates = [];
+  for (const entry of entries) {
+    candidates.push(entry);
+    if (!entry.startsWith("./")) {
+      const dotEntry = entry.startsWith("/") ? `./${entry.slice(1)}` : `./${entry}`;
+      candidates.push(dotEntry);
+    }
+  }
+  return candidates;
+}
+function MapReader(map) {
+  return (path) => {
+    const filename = normalizePath(path);
+    const candidates = buildCandidates(filename);
+    for (const candidate of candidates) {
+      if (map.has(candidate)) {
+        return map.get(candidate) ?? null;
+      }
+    }
+    return null;
+  };
+}
+function normalizeZipEntryName(name) {
+  const normalized = name.replace(/\\/g, "/").replace(/^\.?\//, "");
+  const names = /* @__PURE__ */ new Set();
+  names.add(normalized);
+  if (normalized.startsWith("script/")) {
+    names.add(normalized.slice("script/".length));
+  }
+  return Array.from(names);
+}
+async function ZipReader(data) {
+  const zip = await import_jszip.default.loadAsync(data);
+  const map = /* @__PURE__ */ new Map();
+  const entries = Object.values(zip.files);
+  await Promise.all(
+    entries.map(async (entry) => {
+      if (entry.dir) {
+        return;
+      }
+      if (!entry.name.toLowerCase().endsWith(".lua")) {
+        return;
+      }
+      const content = await entry.async("uint8array");
+      for (const name of normalizeZipEntryName(entry.name)) {
+        map.set(name, content);
+      }
+    })
+  );
+  return MapReader(map);
+}
+
+// src/vendor/script-constants.ts
+var OcgcoreScriptConstants = {
+  ACTIVITY_ATTACK: 5,
+  ACTIVITY_BATTLE_PHASE: 6,
+  ACTIVITY_CHAIN: 7,
+  ACTIVITY_FLIPSUMMON: 4,
+  ACTIVITY_NORMALSUMMON: 2,
+  ACTIVITY_SPSUMMON: 3,
+  ACTIVITY_SUMMON: 1,
+  ASSUME_ATTACK: 7,
+  ASSUME_ATTRIBUTE: 5,
+  ASSUME_CODE: 1,
+  ASSUME_DEFENSE: 8,
+  ASSUME_LEVEL: 3,
+  ASSUME_RACE: 6,
+  ASSUME_RANK: 4,
+  ASSUME_TYPE: 2,
+  ATTRIBUTE_ALL: 127,
+  ATTRIBUTE_DARK: 32,
+  ATTRIBUTE_DIVINE: 64,
+  ATTRIBUTE_EARTH: 1,
+  ATTRIBUTE_FIRE: 4,
+  ATTRIBUTE_LIGHT: 16,
+  ATTRIBUTE_WATER: 2,
+  ATTRIBUTE_WIND: 8,
+  CARD_MARINE_DOLPHIN: 78734254,
+  CARD_QUESTION: 38723936,
+  CARD_TWINKLE_MOSS: 13857930,
+  CATEGORY_ANNOUNCE: 536870912,
+  CATEGORY_ATKCHANGE: 2097152,
+  CATEGORY_COIN: 16777216,
+  CATEGORY_CONTROL: 8192,
+  CATEGORY_COUNTER: 8388608,
+  CATEGORY_DAMAGE: 524288,
+  CATEGORY_DECKDES: 64,
+  CATEGORY_DEFCHANGE: 4194304,
+  CATEGORY_DESTROY: 1,
+  CATEGORY_DICE: 33554432,
+  CATEGORY_DISABLE: 16384,
+  CATEGORY_DISABLE_SUMMON: 32768,
+  CATEGORY_DRAW: 65536,
+  CATEGORY_EQUIP: 262144,
+  CATEGORY_FUSION_SUMMON: 1073741824,
+  CATEGORY_GRAVE_ACTION: 2048,
+  CATEGORY_GRAVE_SPSUMMON: 134217728,
+  CATEGORY_HANDES: 128,
+  CATEGORY_LEAVE_GRAVE: 67108864,
+  CATEGORY_NEGATE: 268435456,
+  CATEGORY_POSITION: 4096,
+  CATEGORY_RECOVER: 1048576,
+  CATEGORY_RELEASE: 2,
+  CATEGORY_REMOVE: 4,
+  CATEGORY_SEARCH: 131072,
+  CATEGORY_SPECIAL_SUMMON: 512,
+  CATEGORY_SUMMON: 256,
+  CATEGORY_TODECK: 16,
+  CATEGORY_TOEXTRA: 2147483648,
+  CATEGORY_TOGRAVE: 32,
+  CATEGORY_TOHAND: 8,
+  CATEGORY_TOKEN: 1024,
+  CHAININFO_CHAIN_COUNT: 1,
+  CHAININFO_CHAIN_ID: 2048,
+  CHAININFO_DISABLE_PLAYER: 1024,
+  CHAININFO_DISABLE_REASON: 512,
+  CHAININFO_EXTTYPE: 8192,
+  CHAININFO_TARGET_CARDS: 64,
+  CHAININFO_TARGET_PARAM: 256,
+  CHAININFO_TARGET_PLAYER: 128,
+  CHAININFO_TRIGGERING_ATTACK: 4194304,
+  CHAININFO_TRIGGERING_ATTRIBUTE: 1048576,
+  CHAININFO_TRIGGERING_CODE: 32768,
+  CHAININFO_TRIGGERING_CODE2: 65536,
+  CHAININFO_TRIGGERING_CONTROLER: 8,
+  CHAININFO_TRIGGERING_DEFENSE: 8388608,
+  CHAININFO_TRIGGERING_EFFECT: 2,
+  CHAININFO_TRIGGERING_LEVEL: 262144,
+  CHAININFO_TRIGGERING_LOCATION: 16,
+  CHAININFO_TRIGGERING_PLAYER: 4,
+  CHAININFO_TRIGGERING_POSITION: 16384,
+  CHAININFO_TRIGGERING_RACE: 2097152,
+  CHAININFO_TRIGGERING_RANK: 524288,
+  CHAININFO_TRIGGERING_SEQUENCE: 32,
+  CHAININFO_TYPE: 4096,
+  CHINT_ATTRIBUTE: 4,
+  CHINT_CARD: 2,
+  CHINT_DESC: 6,
+  CHINT_NUMBER: 5,
+  CHINT_RACE: 3,
+  CHINT_TURN: 1,
+  COUNTER_NEED_ENABLE: 8192,
+  COUNTER_WITHOUT_PERMIT: 4096,
+  DUEL_ATTACK_FIRST_TURN: 2,
+  DUEL_OBSOLETE_RULING: 8,
+  DUEL_OLD_REPLAY: 4,
+  DUEL_PSEUDO_SHUFFLE: 16,
+  DUEL_RETURN_DECK_TOP: 128,
+  DUEL_REVEAL_DECK_SEQ: 256,
+  DUEL_SIMPLE_AI: 64,
+  DUEL_TAG_MODE: 32,
+  DUEL_TEST_MODE: 1,
+  EFFECT_ACTIVATE_COST: 90,
+  EFFECT_ACTIVATION_COUNT_LIMIT: 367,
+  EFFECT_ADD_ATTRIBUTE: 125,
+  EFFECT_ADD_CODE: 113,
+  EFFECT_ADD_EXTRA_TRIBUTE: 157,
+  EFFECT_ADD_FUSION_ATTRIBUTE: 349,
+  EFFECT_ADD_FUSION_CODE: 340,
+  EFFECT_ADD_FUSION_SETCODE: 341,
+  EFFECT_ADD_LINK_ATTRIBUTE: 356,
+  EFFECT_ADD_LINK_CODE: 354,
+  EFFECT_ADD_LINK_RACE: 357,
+  EFFECT_ADD_LINK_SETCODE: 355,
+  EFFECT_ADD_RACE: 120,
+  EFFECT_ADD_SETCODE: 334,
+  EFFECT_ADD_TYPE: 115,
+  EFFECT_ALSO_BATTLE_DAMAGE: 207,
+  EFFECT_ATTACK_ALL: 193,
+  EFFECT_ATTACK_COST: 96,
+  EFFECT_ATTACK_DISABLED: 197,
+  EFFECT_AVOID_BATTLE_DAMAGE: 201,
+  EFFECT_BATTLE_DAMAGE_TO_EFFECT: 205,
+  EFFECT_BATTLE_DESTROY_REDIRECT: 204,
+  EFFECT_BOTH_BATTLE_DAMAGE: 206,
+  EFFECT_BP_TWICE: 296,
+  EFFECT_CANNOT_ACTIVATE: 6,
+  EFFECT_CANNOT_ATTACK: 85,
+  EFFECT_CANNOT_ATTACK_ANNOUNCE: 86,
+  EFFECT_CANNOT_BE_BATTLE_TARGET: 70,
+  EFFECT_CANNOT_BE_EFFECT_TARGET: 71,
+  EFFECT_CANNOT_BP: 185,
+  EFFECT_CANNOT_CHANGE_CONTROL: 5,
+  EFFECT_CANNOT_CHANGE_POSITION: 14,
+  EFFECT_CANNOT_CHANGE_POS_E: 87,
+  EFFECT_CANNOT_DIRECT_ATTACK: 73,
+  EFFECT_CANNOT_DISABLE: 3,
+  EFFECT_CANNOT_DISABLE_FLIP_SUMMON: 39,
+  EFFECT_CANNOT_DISABLE_SPSUMMON: 27,
+  EFFECT_CANNOT_DISABLE_SUMMON: 26,
+  EFFECT_CANNOT_DISCARD_DECK: 56,
+  EFFECT_CANNOT_DISCARD_HAND: 55,
+  EFFECT_CANNOT_DISEFFECT: 13,
+  EFFECT_CANNOT_DRAW: 25,
+  EFFECT_CANNOT_EP: 187,
+  EFFECT_CANNOT_FLIP_SUMMON: 21,
+  EFFECT_CANNOT_INACTIVATE: 12,
+  EFFECT_CANNOT_M2: 186,
+  EFFECT_CANNOT_MSET: 23,
+  EFFECT_CANNOT_PLACE_COUNTER: 58,
+  EFFECT_CANNOT_RELEASE: 46,
+  EFFECT_CANNOT_REMOVE: 67,
+  EFFECT_CANNOT_SELECT_BATTLE_TARGET: 332,
+  EFFECT_CANNOT_SELECT_EFFECT_TARGET: 333,
+  EFFECT_CANNOT_SPECIAL_SUMMON: 22,
+  EFFECT_CANNOT_SSET: 24,
+  EFFECT_CANNOT_SUMMON: 20,
+  EFFECT_CANNOT_TO_DECK: 66,
+  EFFECT_CANNOT_TO_GRAVE: 68,
+  EFFECT_CANNOT_TO_GRAVE_AS_COST: 59,
+  EFFECT_CANNOT_TO_HAND: 65,
+  EFFECT_CANNOT_TRIGGER: 7,
+  EFFECT_CANNOT_TURN_SET: 69,
+  EFFECT_CANNOT_USE_AS_COST: 57,
+  EFFECT_CHAIN_MATERIAL: 231,
+  EFFECT_CHANGE_ATTRIBUTE: 127,
+  EFFECT_CHANGE_BATTLE_DAMAGE: 208,
+  EFFECT_CHANGE_CODE: 114,
+  EFFECT_CHANGE_DAMAGE: 82,
+  EFFECT_CHANGE_ENVIRONMENT: 290,
+  EFFECT_CHANGE_FUSION_ATTRIBUTE: 351,
+  EFFECT_CHANGE_GRAVE_ATTRIBUTE: 365,
+  EFFECT_CHANGE_GRAVE_RACE: 366,
+  EFFECT_CHANGE_INVOLVING_BATTLE_DAMAGE: 314,
+  EFFECT_CHANGE_LEVEL: 131,
+  EFFECT_CHANGE_LSCALE: 135,
+  EFFECT_CHANGE_RACE: 122,
+  EFFECT_CHANGE_RANK: 133,
+  EFFECT_CHANGE_RANK_FINAL: 315,
+  EFFECT_CHANGE_RSCALE: 137,
+  EFFECT_CHANGE_TYPE: 117,
+  EFFECT_COUNT_CODE_CHAIN: 1073741824,
+  EFFECT_COUNT_CODE_DUEL: 536870912,
+  EFFECT_COUNT_CODE_OATH: 268435456,
+  EFFECT_COUNT_CODE_SINGLE: 1,
+  EFFECT_DECREASE_TRIBUTE: 151,
+  EFFECT_DECREASE_TRIBUTE_SET: 152,
+  EFFECT_DEFENSE_ATTACK: 190,
+  EFFECT_DESTROY_REPLACE: 50,
+  EFFECT_DESTROY_SUBSTITUTE: 45,
+  EFFECT_DIRECT_ATTACK: 74,
+  EFFECT_DISABLE: 2,
+  EFFECT_DISABLE_CHAIN: 9,
+  EFFECT_DISABLE_CHAIN_FIELD: 337,
+  EFFECT_DISABLE_EFFECT: 8,
+  EFFECT_DISABLE_FIELD: 260,
+  EFFECT_DISABLE_TRAPMONSTER: 10,
+  EFFECT_DISCARD_COST_CHANGE: 338,
+  EFFECT_DIVINE_LIGHT: 38,
+  EFFECT_DOUBLE_TRIBUTE: 150,
+  EFFECT_DOUBLE_XMATERIAL: 375,
+  EFFECT_DRAW_COUNT: 271,
+  EFFECT_DUAL_STATUS: 75,
+  EFFECT_DUAL_SUMMONABLE: 77,
+  EFFECT_EQUIP_LIMIT: 76,
+  EFFECT_EXTRA_ATTACK: 194,
+  EFFECT_EXTRA_ATTACK_MONSTER: 346,
+  EFFECT_EXTRA_FUSION_MATERIAL: 352,
+  EFFECT_EXTRA_LINK_MATERIAL: 358,
+  EFFECT_EXTRA_PENDULUM_SUMMON: 360,
+  EFFECT_EXTRA_RELEASE: 153,
+  EFFECT_EXTRA_RELEASE_NONSUM: 158,
+  EFFECT_EXTRA_RELEASE_SUM: 155,
+  EFFECT_EXTRA_SET_COUNT: 35,
+  EFFECT_EXTRA_SUMMON_COUNT: 29,
+  EFFECT_EXTRA_SYNCHRO_MATERIAL: 232,
+  EFFECT_FIRST_ATTACK: 192,
+  EFFECT_FLAG2_COF: 2,
+  EFFECT_FLAG2_OPTION: 8,
+  EFFECT_FLAG2_REPEAT_UPDATE: 1,
+  EFFECT_FLAG2_WICKED: 4,
+  EFFECT_FLAG_ABSOLUTE_TARGET: 64,
+  EFFECT_FLAG_ACTIVATE_CONDITION: 536870912,
+  EFFECT_FLAG_BOTH_SIDE: 4096,
+  EFFECT_FLAG_CANNOT_DISABLE: 1024,
+  EFFECT_FLAG_CANNOT_INACTIVATE: 33554432,
+  EFFECT_FLAG_CAN_FORBIDDEN: 512,
+  EFFECT_FLAG_CARD_TARGET: 16,
+  EFFECT_FLAG_CLIENT_HINT: 67108864,
+  EFFECT_FLAG_COIN: 4294967296,
+  EFFECT_FLAG_CONTINUOUS_TARGET: 134217728,
+  EFFECT_FLAG_COPY: 8192,
+  EFFECT_FLAG_COUNT_LIMIT: 4,
+  EFFECT_FLAG_CVAL_CHECK: 1073741824,
+  EFFECT_FLAG_DAMAGE_CAL: 32768,
+  EFFECT_FLAG_DAMAGE_STEP: 16384,
+  EFFECT_FLAG_DELAY: 65536,
+  EFFECT_FLAG_DICE: 8589934592,
+  EFFECT_FLAG_EFFECT: 536870912,
+  EFFECT_FLAG_EVENT_PLAYER: 8388608,
+  EFFECT_FLAG_FIELD_ONLY: 8,
+  EFFECT_FLAG_FUNC_VALUE: 2,
+  EFFECT_FLAG_FUSION_SUMMON: 17179869184,
+  EFFECT_FLAG_IGNORE_IMMUNE: 128,
+  EFFECT_FLAG_IGNORE_RANGE: 32,
+  EFFECT_FLAG_IMMEDIATELY_APPLY: 2147483648,
+  EFFECT_FLAG_INITIAL: 1,
+  EFFECT_FLAG_LIMIT_ZONE: 268435456,
+  EFFECT_FLAG_NO_TURN_RESET: 4194304,
+  EFFECT_FLAG_OATH: 524288,
+  EFFECT_FLAG_OWNER_RELATE: 16777216,
+  EFFECT_FLAG_PLAYER_TARGET: 2048,
+  EFFECT_FLAG_REPEAT: 2097152,
+  EFFECT_FLAG_SET_AVAILABLE: 256,
+  EFFECT_FLAG_SINGLE_RANGE: 131072,
+  EFFECT_FLAG_SPSUM_PARAM: 1048576,
+  EFFECT_FLAG_UNCOPYABLE: 262144,
+  EFFECT_FLIPSUMMON_COST: 93,
+  EFFECT_FORBIDDEN: 292,
+  EFFECT_FUSION_MATERIAL: 230,
+  EFFECT_FUSION_SUBSTITUTE: 234,
+  EFFECT_HAND_LIMIT: 270,
+  EFFECT_HAND_SYNCHRO: 339,
+  EFFECT_IGNORE_BATTLE_TARGET: 72,
+  EFFECT_IMMUNE_EFFECT: 1,
+  EFFECT_INDESTRUCTABLE: 40,
+  EFFECT_INDESTRUCTABLE_BATTLE: 42,
+  EFFECT_INDESTRUCTABLE_COUNT: 47,
+  EFFECT_INDESTRUCTABLE_EFFECT: 41,
+  EFFECT_KAISER_COLOSSEUM: 370,
+  EFFECT_LEAVE_FIELD_REDIRECT: 60,
+  EFFECT_LEFT_SPSUMMON_COUNT: 331,
+  EFFECT_LIMIT_SET_PROC: 37,
+  EFFECT_LIMIT_SPECIAL_SUMMON_POSITION: 368,
+  EFFECT_LIMIT_SUMMON_PROC: 33,
+  EFFECT_LPCOST_CHANGE: 170,
+  EFFECT_LPCOST_REPLACE: 171,
+  EFFECT_MATCH_KILL: 300,
+  EFFECT_MATERIAL_CHECK: 251,
+  EFFECT_MATERIAL_LIMIT: 361,
+  EFFECT_MAX_MZONE: 263,
+  EFFECT_MAX_SZONE: 264,
+  EFFECT_MONSTER_SSET: 18,
+  EFFECT_MSET_COST: 94,
+  EFFECT_MUST_ATTACK: 191,
+  EFFECT_MUST_ATTACK_MONSTER: 344,
+  EFFECT_MUST_BE_ATTACKED: 195,
+  EFFECT_MUST_BE_FMATERIAL: 316,
+  EFFECT_MUST_BE_LMATERIAL: 318,
+  EFFECT_MUST_BE_SMATERIAL: 312,
+  EFFECT_MUST_BE_XMATERIAL: 317,
+  EFFECT_MUST_USE_MZONE: 265,
+  EFFECT_NECRO_VALLEY: 291,
+  EFFECT_NECRO_VALLEY_IM: 293,
+  EFFECT_NO_BATTLE_DAMAGE: 200,
+  EFFECT_NO_EFFECT_DAMAGE: 335,
+  EFFECT_OLDUNION_STATUS: 348,
+  EFFECT_ONLY_ATTACK_MONSTER: 343,
+  EFFECT_ONLY_BE_ATTACKED: 196,
+  EFFECT_OVERLAY_RITUAL_MATERIAL: 364,
+  EFFECT_PATRICIAN_OF_DARKNESS: 345,
+  EFFECT_PIERCE: 203,
+  EFFECT_PRE_MONSTER: 250,
+  EFFECT_PUBLIC: 160,
+  EFFECT_QP_ACT_IN_NTPHAND: 311,
+  EFFECT_QP_ACT_IN_SET_TURN: 359,
+  EFFECT_REFLECT_BATTLE_DAMAGE: 202,
+  EFFECT_REFLECT_DAMAGE: 83,
+  EFFECT_RELEASE_REPLACE: 51,
+  EFFECT_REMAIN_FIELD: 17,
+  EFFECT_REMOVE_ATTRIBUTE: 126,
+  EFFECT_REMOVE_BRAINWASHING: 295,
+  EFFECT_REMOVE_FUSION_ATTRIBUTE: 350,
+  EFFECT_REMOVE_RACE: 121,
+  EFFECT_REMOVE_REDIRECT: 64,
+  EFFECT_REMOVE_TYPE: 116,
+  EFFECT_REPLACE_DAMAGE: 371,
+  EFFECT_REVERSE_DAMAGE: 80,
+  EFFECT_REVERSE_DECK: 294,
+  EFFECT_REVERSE_RECOVER: 81,
+  EFFECT_REVERSE_UPDATE: 108,
+  EFFECT_REVIVE_LIMIT: 31,
+  EFFECT_RISE_TO_FULL_HEIGHT: 342,
+  EFFECT_RITUAL_LEVEL_EX: 374,
+  EFFECT_SELF_DESTROY: 141,
+  EFFECT_SELF_TOGRAVE: 142,
+  EFFECT_SEND_REPLACE: 52,
+  EFFECT_SET_ATTACK: 101,
+  EFFECT_SET_ATTACK_FINAL: 102,
+  EFFECT_SET_BASE_ATTACK: 103,
+  EFFECT_SET_BASE_ATTACK_FINAL: 111,
+  EFFECT_SET_BASE_DEFENSE: 107,
+  EFFECT_SET_BASE_DEFENSE_FINAL: 112,
+  EFFECT_SET_BATTLE_ATTACK: 362,
+  EFFECT_SET_BATTLE_DEFENSE: 363,
+  EFFECT_SET_CONTROL: 4,
+  EFFECT_SET_DEFENSE: 105,
+  EFFECT_SET_DEFENSE_FINAL: 106,
+  EFFECT_SET_POSITION: 140,
+  EFFECT_SET_PROC: 36,
+  EFFECT_SET_SUMMON_COUNT_LIMIT: 28,
+  EFFECT_SKIP_BP: 183,
+  EFFECT_SKIP_DP: 180,
+  EFFECT_SKIP_M1: 182,
+  EFFECT_SKIP_M2: 184,
+  EFFECT_SKIP_SP: 181,
+  EFFECT_SKIP_TURN: 188,
+  EFFECT_SPIRIT_DONOT_RETURN: 280,
+  EFFECT_SPIRIT_MAYNOT_RETURN: 281,
+  EFFECT_SPSUMMON_CONDITION: 30,
+  EFFECT_SPSUMMON_COST: 92,
+  EFFECT_SPSUMMON_COUNT_LIMIT: 330,
+  EFFECT_SPSUMMON_PROC: 34,
+  EFFECT_SPSUMMON_PROC_G: 320,
+  EFFECT_SSET_COST: 95,
+  EFFECT_SUMMON_COST: 91,
+  EFFECT_SUMMON_PROC: 32,
+  EFFECT_SWAP_AD: 109,
+  EFFECT_SWAP_BASE_AD: 110,
+  EFFECT_SYNCHRO_CHECK: 310,
+  EFFECT_SYNCHRO_LEVEL_EX: 373,
+  EFFECT_TOSS_COIN_REPLACE: 220,
+  EFFECT_TOSS_DICE_REPLACE: 221,
+  EFFECT_TO_DECK_REDIRECT: 62,
+  EFFECT_TO_GRAVE_REDIRECT: 63,
+  EFFECT_TO_GRAVE_REDIRECT_CB: 313,
+  EFFECT_TO_HAND_REDIRECT: 61,
+  EFFECT_TRAP_ACT_IN_HAND: 15,
+  EFFECT_TRAP_ACT_IN_SET_TURN: 16,
+  EFFECT_TRIBUTE_LIMIT: 154,
+  EFFECT_TRIPLE_TRIBUTE: 156,
+  EFFECT_TUNER: 369,
+  EFFECT_TUNER_MATERIAL_LIMIT: 353,
+  EFFECT_TYPE_ACTIONS: 8,
+  EFFECT_TYPE_ACTIVATE: 16,
+  EFFECT_TYPE_CONTINUOUS: 2048,
+  EFFECT_TYPE_EQUIP: 4,
+  EFFECT_TYPE_FIELD: 2,
+  EFFECT_TYPE_FLIP: 32,
+  EFFECT_TYPE_GRANT: 8192,
+  EFFECT_TYPE_IGNITION: 64,
+  EFFECT_TYPE_QUICK_F: 1024,
+  EFFECT_TYPE_QUICK_O: 256,
+  EFFECT_TYPE_SINGLE: 1,
+  EFFECT_TYPE_TARGET: 16384,
+  EFFECT_TYPE_TRIGGER_F: 512,
+  EFFECT_TYPE_TRIGGER_O: 128,
+  EFFECT_TYPE_XMATERIAL: 4096,
+  EFFECT_UNION_LIMIT: 78,
+  EFFECT_UNION_STATUS: 347,
+  EFFECT_UNIQUE_CHECK: 297,
+  EFFECT_UNRELEASABLE_EFFECT: 48,
+  EFFECT_UNRELEASABLE_NONSUM: 44,
+  EFFECT_UNRELEASABLE_SUM: 43,
+  EFFECT_UNSUMMONABLE_CARD: 336,
+  EFFECT_UPDATE_ATTACK: 100,
+  EFFECT_UPDATE_DEFENSE: 104,
+  EFFECT_UPDATE_LEVEL: 130,
+  EFFECT_UPDATE_LSCALE: 134,
+  EFFECT_UPDATE_RANK: 132,
+  EFFECT_UPDATE_RSCALE: 136,
+  EFFECT_USE_EXTRA_MZONE: 261,
+  EFFECT_USE_EXTRA_SZONE: 262,
+  EFFECT_XYZ_MATERIAL: 233,
+  EFFECT_XYZ_MIN_COUNT: 372,
+  EVENT_ADD_COUNTER: 65536,
+  EVENT_ADJUST: 1040,
+  EVENT_ATTACK_ANNOUNCE: 1130,
+  EVENT_ATTACK_DISABLED: 1142,
+  EVENT_BATTLED: 1138,
+  EVENT_BATTLE_CONFIRM: 1133,
+  EVENT_BATTLE_DAMAGE: 1143,
+  EVENT_BATTLE_DESTROYED: 1140,
+  EVENT_BATTLE_DESTROYING: 1139,
+  EVENT_BATTLE_END: 1137,
+  EVENT_BATTLE_START: 1132,
+  EVENT_BECOME_TARGET: 1028,
+  EVENT_BE_BATTLE_TARGET: 1131,
+  EVENT_BE_MATERIAL: 1108,
+  EVENT_BE_PRE_MATERIAL: 1109,
+  EVENT_BREAK_EFFECT: 1050,
+  EVENT_CHAINING: 1027,
+  EVENT_CHAIN_ACTIVATED: 1023,
+  EVENT_CHAIN_ACTIVATING: 1021,
+  EVENT_CHAIN_DISABLED: 1025,
+  EVENT_CHAIN_END: 1026,
+  EVENT_CHAIN_NEGATED: 1024,
+  EVENT_CHAIN_SOLVED: 1022,
+  EVENT_CHAIN_SOLVING: 1020,
+  EVENT_CHANGE_POS: 1016,
+  EVENT_CONTROL_CHANGED: 1120,
+  EVENT_CUSTOM: 268435456,
+  EVENT_DAMAGE: 1111,
+  EVENT_DAMAGE_CALCULATING: 1135,
+  EVENT_DAMAGE_STEP_END: 1141,
+  EVENT_DESTROY: 1010,
+  EVENT_DESTROYED: 1029,
+  EVENT_DETACH_MATERIAL: 1202,
+  EVENT_DISCARD: 1018,
+  EVENT_DRAW: 1110,
+  EVENT_EQUIP: 1121,
+  EVENT_FLIP: 1001,
+  EVENT_FLIP_SUMMON: 1104,
+  EVENT_FLIP_SUMMON_NEGATED: 1115,
+  EVENT_FLIP_SUMMON_SUCCESS: 1101,
+  EVENT_FREE_CHAIN: 1002,
+  EVENT_LEAVE_DECK: 1032,
+  EVENT_LEAVE_FIELD: 1015,
+  EVENT_LEAVE_FIELD_P: 1019,
+  EVENT_LEAVE_GRAVE: 1031,
+  EVENT_LEVEL_UP: 1200,
+  EVENT_MOVE: 1030,
+  EVENT_MSET: 1106,
+  EVENT_PAY_LPCOST: 1201,
+  EVENT_PHASE: 4096,
+  EVENT_PHASE_START: 8192,
+  EVENT_PREDRAW: 1113,
+  EVENT_PRE_BATTLE_DAMAGE: 1136,
+  EVENT_PRE_DAMAGE_CALCULATE: 1134,
+  EVENT_RECOVER: 1112,
+  EVENT_RELEASE: 1017,
+  EVENT_REMOVE: 1011,
+  EVENT_REMOVE_COUNTER: 131072,
+  EVENT_RETURN_TO_GRAVE: 1203,
+  EVENT_SPSUMMON: 1105,
+  EVENT_SPSUMMON_NEGATED: 1116,
+  EVENT_SPSUMMON_SUCCESS: 1102,
+  EVENT_SPSUMMON_SUCCESS_G_P: 1117,
+  EVENT_SSET: 1107,
+  EVENT_STARTUP: 1e3,
+  EVENT_SUMMON: 1103,
+  EVENT_SUMMON_NEGATED: 1114,
+  EVENT_SUMMON_SUCCESS: 1100,
+  EVENT_TOSS_COIN: 1151,
+  EVENT_TOSS_COIN_NEGATE: 1152,
+  EVENT_TOSS_DICE: 1150,
+  EVENT_TOSS_DICE_NEGATE: 1153,
+  EVENT_TO_DECK: 1013,
+  EVENT_TO_GRAVE: 1014,
+  EVENT_TO_HAND: 1012,
+  EVENT_TURN_END: 1210,
+  FLAG_ID_ALLURE_QUEEN: 4,
+  FLAG_ID_ARCANA_COIN: 5,
+  FLAG_ID_CHAINING: 1,
+  FLAG_ID_NO_NORMAL_DRAW: 3,
+  FLAG_ID_REVERSAL_OF_FATE: 36690018,
+  FLAG_ID_UNION: 2,
+  GLOBALFLAG_BRAINWASHING_CHECK: 2,
+  GLOBALFLAG_DECK_REVERSE_CHECK: 1,
+  GLOBALFLAG_DELAYED_QUICKEFFECT: 8,
+  GLOBALFLAG_DETACH_EVENT: 16,
+  GLOBALFLAG_MUST_BE_SMATERIAL: 32,
+  GLOBALFLAG_SCRAP_CHIMERA: 4,
+  GLOBALFLAG_SELF_TOGRAVE: 256,
+  GLOBALFLAG_SPSUMMON_COUNT: 64,
+  GLOBALFLAG_SPSUMMON_ONCE: 512,
+  GLOBALFLAG_TUNE_MAGICIAN: 1024,
+  GLOBALFLAG_XMAT_COUNT_LIMIT: 128,
+  HINGMSG_LVRANK: 567,
+  HINGMSG_NUMBER: 565,
+  HINTMSG_ATOHAND: 506,
+  HINTMSG_ATTACK: 516,
+  HINTMSG_ATTACKTARGET: 549,
+  HINTMSG_ATTRIBUTE: 562,
+  HINTMSG_CARDTYPE: 554,
+  HINTMSG_CODE: 564,
+  HINTMSG_COIN: 552,
+  HINTMSG_CONFIRM: 526,
+  HINTMSG_CONTROL: 520,
+  HINTMSG_COUNTER: 572,
+  HINTMSG_DEATTACHFROM: 532,
+  HINTMSG_DEFENSE: 517,
+  HINTMSG_DESREPLACE: 521,
+  HINTMSG_DESTROY: 502,
+  HINTMSG_DICE: 553,
+  HINTMSG_DISABLE: 573,
+  HINTMSG_DISABLEZONE: 570,
+  HINTMSG_DISCARD: 501,
+  HINTMSG_EFFECT: 550,
+  HINTMSG_EQUIP: 518,
+  HINTMSG_FACEDOWN: 515,
+  HINTMSG_FACEDOWNATTACK: 524,
+  HINTMSG_FACEDOWNDEFENSE: 525,
+  HINTMSG_FACEUP: 514,
+  HINTMSG_FACEUPATTACK: 522,
+  HINTMSG_FACEUPDEFENSE: 523,
+  HINTMSG_FIELD_FIRST: 575,
+  HINTMSG_FMATERIAL: 511,
+  HINTMSG_LMATERIAL: 533,
+  HINTMSG_OPERATECARD: 574,
+  HINTMSG_OPPO: 530,
+  HINTMSG_OPTION: 555,
+  HINTMSG_POSCHANGE: 528,
+  HINTMSG_POSITION: 561,
+  HINTMSG_RACE: 563,
+  HINTMSG_RELEASE: 500,
+  HINTMSG_REMOVE: 503,
+  HINTMSG_REMOVEXYZ: 519,
+  HINTMSG_RESOLVECARD: 568,
+  HINTMSG_RESOLVEEFFECT: 556,
+  HINTMSG_RTOHAND: 505,
+  HINTMSG_SELECT: 560,
+  HINTMSG_SELF: 529,
+  HINTMSG_SET: 510,
+  HINTMSG_SMATERIAL: 512,
+  HINTMSG_SPSUMMON: 509,
+  HINTMSG_SUMMON: 508,
+  HINTMSG_TARGET: 551,
+  HINTMSG_TODECK: 507,
+  HINTMSG_TOFIELD: 527,
+  HINTMSG_TOGRAVE: 504,
+  HINTMSG_TOZONE: 571,
+  HINTMSG_TRIBUTE: 531,
+  HINTMSG_XMATERIAL: 513,
+  HINTMSG_ZONE: 569,
+  HINT_ATTRIB: 7,
+  HINT_CARD: 10,
+  HINT_CODE: 8,
+  HINT_EFFECT: 5,
+  HINT_EVENT: 1,
+  HINT_MESSAGE: 2,
+  HINT_NUMBER: 9,
+  HINT_OPSELECTED: 4,
+  HINT_RACE: 6,
+  HINT_SELECTMSG: 3,
+  HINT_ZONE: 11,
+  LINK_MARKER_BOTTOM: 2,
+  LINK_MARKER_BOTTOM_LEFT: 1,
+  LINK_MARKER_BOTTOM_RIGHT: 4,
+  LINK_MARKER_LEFT: 8,
+  LINK_MARKER_RIGHT: 32,
+  LINK_MARKER_TOP: 128,
+  LINK_MARKER_TOP_LEFT: 64,
+  LINK_MARKER_TOP_RIGHT: 256,
+  LOCATION_DECK: 1,
+  LOCATION_DECKBOT: 65537,
+  LOCATION_DECKSHF: 131073,
+  LOCATION_EXTRA: 64,
+  LOCATION_FZONE: 256,
+  LOCATION_GRAVE: 16,
+  LOCATION_HAND: 2,
+  LOCATION_MZONE: 4,
+  LOCATION_ONFIELD: 12,
+  LOCATION_OVERLAY: 128,
+  LOCATION_PZONE: 512,
+  LOCATION_REASON_CONTROL: 2,
+  LOCATION_REASON_TOFIELD: 1,
+  LOCATION_REMOVED: 32,
+  LOCATION_SZONE: 8,
+  MASTER_RULE3: 3,
+  MASTER_RULE_2020: 5,
+  MAX_COUNTER: 65535,
+  MAX_ID: 268435455,
+  MAX_PARAMETER: 65535,
+  MAX_XYZ_LEVEL: 4095,
+  MIN_ID: 128,
+  NEW_MASTER_RULE: 4,
+  OPCODE_ADD: 1073741824,
+  OPCODE_AND: 1073741828,
+  OPCODE_DIV: 1073741827,
+  OPCODE_ISATTRIBUTE: 1073742084,
+  OPCODE_ISCODE: 1073742080,
+  OPCODE_ISRACE: 1073742083,
+  OPCODE_ISSETCARD: 1073742081,
+  OPCODE_ISTYPE: 1073742082,
+  OPCODE_MUL: 1073741826,
+  OPCODE_NEG: 1073741830,
+  OPCODE_NOT: 1073741831,
+  OPCODE_OR: 1073741829,
+  OPCODE_SUB: 1073741825,
+  PHASE_BATTLE: 128,
+  PHASE_BATTLE_START: 8,
+  PHASE_BATTLE_STEP: 16,
+  PHASE_DAMAGE: 32,
+  PHASE_DAMAGE_CAL: 64,
+  PHASE_DRAW: 1,
+  PHASE_END: 512,
+  PHASE_MAIN1: 4,
+  PHASE_MAIN2: 256,
+  PHASE_STANDBY: 2,
+  PLAYER_ALL: 3,
+  PLAYER_NONE: 2,
+  POS_ATTACK: 3,
+  POS_DEFENSE: 12,
+  POS_FACEDOWN: 10,
+  POS_FACEDOWN_ATTACK: 2,
+  POS_FACEDOWN_DEFENSE: 8,
+  POS_FACEUP: 5,
+  POS_FACEUP_ATTACK: 1,
+  POS_FACEUP_DEFENSE: 4,
+  RACE_ALL: 67108863,
+  RACE_AQUA: 64,
+  RACE_BEAST: 16384,
+  RACE_BEASTWARRIOR: 32768,
+  RACE_CREATORGOD: 4194304,
+  RACE_CYBERSE: 16777216,
+  RACE_DINOSAUR: 65536,
+  RACE_DIVINE: 2097152,
+  RACE_DRAGON: 8192,
+  RACE_FAIRY: 4,
+  RACE_FIEND: 8,
+  RACE_FISH: 131072,
+  RACE_ILLUSION: 33554432,
+  RACE_INSECT: 2048,
+  RACE_MACHINE: 32,
+  RACE_PLANT: 1024,
+  RACE_PSYCHO: 1048576,
+  RACE_PYRO: 128,
+  RACE_REPTILE: 524288,
+  RACE_ROCK: 256,
+  RACE_SEASERPENT: 262144,
+  RACE_SPELLCASTER: 2,
+  RACE_THUNDER: 4096,
+  RACE_WARRIOR: 1,
+  RACE_WINDBEAST: 512,
+  RACE_WYRM: 8388608,
+  RACE_ZOMBIE: 16,
+  REASON_ACTION: 2147483648,
+  REASON_ADJUST: 256,
+  REASON_BATTLE: 32,
+  REASON_COST: 128,
+  REASON_DESTROY: 1,
+  REASON_DISCARD: 16384,
+  REASON_DISSUMMON: 4096,
+  REASON_DRAW: 33554432,
+  REASON_EFFECT: 64,
+  REASON_FLIP: 8192,
+  REASON_FUSION: 262144,
+  REASON_LINK: 268435456,
+  REASON_LOST_OVERLAY: 536870912,
+  REASON_LOST_TARGET: 512,
+  REASON_MAINTENANCE: 1073741824,
+  REASON_MATERIAL: 8,
+  REASON_RDAMAGE: 32768,
+  REASON_REDIRECT: 67108864,
+  REASON_RELEASE: 2,
+  REASON_REPLACE: 16777216,
+  REASON_RETURN: 131072,
+  REASON_REVEAL: 134217728,
+  REASON_RITUAL: 1048576,
+  REASON_RRECOVER: 65536,
+  REASON_RULE: 1024,
+  REASON_SPSUMMON: 2048,
+  REASON_SUMMON: 16,
+  REASON_SYNCHRO: 524288,
+  REASON_TEMPORARY: 4,
+  REASON_XYZ: 2097152,
+  RESETS_REDIRECT: 209584128,
+  RESETS_STANDARD: 33423360,
+  RESETS_WITHOUT_TEMP_REMOVE: 91095040,
+  RESET_CARD: 8192,
+  RESET_CHAIN: 2147483648,
+  RESET_CODE: 16384,
+  RESET_CONTROL: 33554432,
+  RESET_COPY: 32768,
+  RESET_DISABLE: 65536,
+  RESET_EVENT: 4096,
+  RESET_LEAVE: 8388608,
+  RESET_MSCHANGE: 134217728,
+  RESET_OPPO_TURN: 536870912,
+  RESET_OVERLAY: 67108864,
+  RESET_PHASE: 1073741824,
+  RESET_REMOVE: 524288,
+  RESET_SELF_TURN: 268435456,
+  RESET_TEMP_REMOVE: 1048576,
+  RESET_TODECK: 4194304,
+  RESET_TOFIELD: 16777216,
+  RESET_TOGRAVE: 262144,
+  RESET_TOHAND: 2097152,
+  RESET_TURN_SET: 131072,
+  SELECT_HEADS: 60,
+  SELECT_TAILS: 61,
+  SEQ_DECKBOTTOM: 1,
+  SEQ_DECKSHUFFLE: 2,
+  SEQ_DECKTOP: 0,
+  STATUS_ACTIVATE_DISABLED: 262144,
+  STATUS_ACT_FROM_HAND: 134217728,
+  STATUS_ATTACK_CANCELED: 2097152,
+  STATUS_BATTLE_DESTROYED: 16384,
+  STATUS_BATTLE_RESULT: 64,
+  STATUS_CANNOT_CHANGE_FORM: 256,
+  STATUS_CHAINING: 65536,
+  STATUS_CONTINUOUS_POS: 33554432,
+  STATUS_COPYING_EFFECT: 32768,
+  STATUS_DESTROY_CONFIRMED: 4096,
+  STATUS_DISABLED: 1,
+  STATUS_EFFECT_ENABLED: 1024,
+  STATUS_EFFECT_REPLACED: 524288,
+  STATUS_FLIP_SUMMONING: 1048576,
+  STATUS_FLIP_SUMMON_DISABLED: 2147483648,
+  STATUS_FLIP_SUMMON_TURN: 536870912,
+  STATUS_FORBIDDEN: 67108864,
+  STATUS_INITIALIZING: 4194304,
+  STATUS_JUST_POS: 16777216,
+  STATUS_LEAVE_CONFIRMED: 8192,
+  STATUS_NO_LEVEL: 32,
+  STATUS_OPPO_BATTLE: 268435456,
+  STATUS_PROC_COMPLETE: 8,
+  STATUS_SET_TURN: 16,
+  STATUS_SPSUMMON_STEP: 128,
+  STATUS_SPSUMMON_TURN: 1073741824,
+  STATUS_SUMMONING: 512,
+  STATUS_SUMMON_DISABLED: 131072,
+  STATUS_SUMMON_TURN: 2048,
+  STATUS_TO_DISABLE: 4,
+  STATUS_TO_ENABLE: 2,
+  STATUS_TO_HAND_WITHOUT_CONFIRM: 8388608,
+  SUMMON_INFO_ATTACK: 128,
+  SUMMON_INFO_ATTRIBUTE: 32,
+  SUMMON_INFO_CODE: 1,
+  SUMMON_INFO_CODE2: 2,
+  SUMMON_INFO_DEFENSE: 256,
+  SUMMON_INFO_LEVEL: 8,
+  SUMMON_INFO_RACE: 64,
+  SUMMON_INFO_RANK: 16,
+  SUMMON_INFO_REASON_EFFECT: 512,
+  SUMMON_INFO_REASON_PLAYER: 1024,
+  SUMMON_INFO_TYPE: 4,
+  SUMMON_TYPE_ADVANCE: 285212672,
+  SUMMON_TYPE_DUAL: 301989888,
+  SUMMON_TYPE_FLIP: 536870912,
+  SUMMON_TYPE_FUSION: 1124073472,
+  SUMMON_TYPE_LINK: 1275068416,
+  SUMMON_TYPE_NORMAL: 268435456,
+  SUMMON_TYPE_PENDULUM: 1241513984,
+  SUMMON_TYPE_RITUAL: 1157627904,
+  SUMMON_TYPE_SPECIAL: 1073741824,
+  SUMMON_TYPE_SYNCHRO: 1174405120,
+  SUMMON_TYPE_XYZ: 1224736768,
+  SUMMON_VALUE_ASSAULT_MODE: 21,
+  SUMMON_VALUE_DARK_FUSION: 1124073494,
+  SUMMON_VALUE_DARK_SANCTUARY: 18,
+  SUMMON_VALUE_EVOLTILE: 16384,
+  SUMMON_VALUE_FOSSIL_FUSION: 1124073495,
+  SUMMON_VALUE_FUTURE_FUSION: 1124073496,
+  SUMMON_VALUE_GLADIATOR: 8192,
+  SUMMON_VALUE_LV: 4096,
+  SUMMON_VALUE_MASK_CHANGE: 20,
+  SUMMON_VALUE_MONSTER_REBORN: 19,
+  SUMMON_VALUE_SELF: 1,
+  SUMMON_VALUE_SYNCHRO_MATERIAL: 17,
+  TIMINGS_CHECK_MONSTER: 448,
+  TIMING_ATTACK: 4096,
+  TIMING_BATTLED: 134217728,
+  TIMING_BATTLE_END: 16,
+  TIMING_BATTLE_PHASE: 16777216,
+  TIMING_BATTLE_START: 8,
+  TIMING_BATTLE_STEP_END: 67108864,
+  TIMING_CHAIN_END: 32768,
+  TIMING_DAMAGE: 131072,
+  TIMING_DAMAGE_CAL: 16384,
+  TIMING_DAMAGE_STEP: 8192,
+  TIMING_DESTROY: 524288,
+  TIMING_DRAW: 65536,
+  TIMING_DRAW_PHASE: 1,
+  TIMING_END_PHASE: 32,
+  TIMING_EQUIP: 33554432,
+  TIMING_FLIPSUMMON: 256,
+  TIMING_MAIN_END: 4,
+  TIMING_MSET: 512,
+  TIMING_POS_CHANGE: 2048,
+  TIMING_RECOVER: 262144,
+  TIMING_REMOVE: 1048576,
+  TIMING_SPSUMMON: 128,
+  TIMING_SSET: 1024,
+  TIMING_STANDBY_PHASE: 2,
+  TIMING_SUMMON: 64,
+  TIMING_TODECK: 4194304,
+  TIMING_TOGRAVE: 8388608,
+  TIMING_TOHAND: 2097152,
+  TYPES_EFFECT_TRAP_MONSTER: 289,
+  TYPES_NORMAL_TRAP_MONSTER: 273,
+  TYPES_TOKEN_MONSTER: 16401,
+  TYPE_CONTINUOUS: 131072,
+  TYPE_COUNTER: 1048576,
+  TYPE_DUAL: 2048,
+  TYPE_EFFECT: 32,
+  TYPE_EQUIP: 262144,
+  TYPE_FIELD: 524288,
+  TYPE_FLIP: 2097152,
+  TYPE_FUSION: 64,
+  TYPE_LINK: 67108864,
+  TYPE_MONSTER: 1,
+  TYPE_NORMAL: 16,
+  TYPE_PENDULUM: 16777216,
+  TYPE_QUICKPLAY: 65536,
+  TYPE_RITUAL: 128,
+  TYPE_SPELL: 2,
+  TYPE_SPIRIT: 512,
+  TYPE_SPSUMMON: 33554432,
+  TYPE_SYNCHRO: 8192,
+  TYPE_TOKEN: 16384,
+  TYPE_TOON: 4194304,
+  TYPE_TRAP: 4,
+  TYPE_TRAPMONSTER: 256,
+  TYPE_TUNER: 4096,
+  TYPE_UNION: 1024,
+  TYPE_XYZ: 8388608
+};
+
+// src/sqljs-card-reader.ts
+function toUint16ArrayFromSetcode(value) {
+  let raw = typeof value === "bigint" ? value : BigInt(value >>> 0);
+  const list = new Uint16Array(16);
+  let idx = 0;
+  while (raw !== 0n && idx < 16) {
+    const chunk = raw & 0xffffn;
+    if (chunk !== 0n) {
+      list[idx] = Number(chunk);
+      idx++;
+    }
+    raw >>= 16n;
+  }
+  return list;
+}
+function mapRowToCardData(row) {
+  const type = (row.type ?? 0) >>> 0;
+  let attack = row.atk ?? 0;
+  let defense = row.def ?? 0;
+  let linkMarker = 0;
+  if ((type & OcgcoreCommonConstants.TYPE_LINK) >>> 0 !== 0) {
+    linkMarker = defense;
+    defense = 0;
+  }
+  const levelRaw = (row.level ?? 0) >>> 0;
+  const level = (levelRaw & 255) >>> 0;
+  const lscale = (levelRaw >>> 24 & 255) >>> 0;
+  const rscale = (levelRaw >>> 16 & 255) >>> 0;
+  return {
+    code: row.id,
+    alias: row.alias ?? 0,
+    setcode: toUint16ArrayFromSetcode(row.setcode ?? 0),
+    type,
+    level,
+    attribute: (row.attribute ?? 0) >>> 0,
+    race: (row.race ?? 0) >>> 0,
+    attack,
+    defense,
+    lscale,
+    rscale,
+    linkMarker
+  };
+}
+function queryOne(db, cardId) {
+  if (typeof db.prepare === "function") {
+    const stmt = db.prepare(
+      "SELECT id, alias, setcode, type, atk, def, level, race, attribute FROM datas WHERE id = ?"
+    );
+    try {
+      stmt.bind([cardId]);
+      if (!stmt.step()) {
+        return null;
+      }
+      const row2 = stmt.getAsObject();
+      if (!row2 || row2.id == null) {
+        return null;
+      }
+      return mapRowToCardData(row2);
+    } finally {
+      stmt.free();
+    }
+  }
+  const res = db.exec(
+    `SELECT id, alias, setcode, type, atk, def, level, race, attribute FROM datas WHERE id = ${cardId}`
+  );
+  if (!res || res.length === 0 || !res[0].values || res[0].values.length === 0) {
+    return null;
+  }
+  const row = res[0].values[0];
+  return mapRowToCardData({
+    id: row[0],
+    alias: row[1],
+    setcode: row[2],
+    type: row[3],
+    atk: row[4],
+    def: row[5],
+    level: row[6],
+    race: row[7],
+    attribute: row[8]
+  });
+}
+function createSqljsCardReader(...dbs) {
+  return (cardId) => {
+    for (const db of dbs) {
+      const data = queryOne(db, cardId);
+      if (data) {
+        return data;
+      }
+    }
+    return null;
+  };
+}
+
+// src/play-yrp.ts
+var import_ygopro_yrp_encode = require("ygopro-yrp-encode");
+var { LOCATION_DECK, LOCATION_EXTRA, POS_FACEDOWN_DEFENSE } = OcgcoreScriptConstants;
+function normalizeYrp(input) {
+  if (input instanceof import_ygopro_yrp_encode.YGOProYrp) {
+    return input;
+  }
+  return new import_ygopro_yrp_encode.YGOProYrp().fromYrp(input);
+}
+function createReplayDuel(wrapper, yrp) {
+  const header = yrp.header;
+  const seedSequence = header?.seedSequence ?? [];
+  if (seedSequence.length > 0) {
+    return wrapper.createDuelV2(seedSequence);
+  }
+  return wrapper.createDuel(header?.seed ?? 0);
+}
+function loadDeck(duel, deck, owner, playerId) {
+  if (!deck) return;
+  for (const code of deck.main ?? []) {
+    duel.newCard({
+      code,
+      owner,
+      playerId,
+      location: LOCATION_DECK,
+      sequence: 0,
+      position: POS_FACEDOWN_DEFENSE
+    });
+  }
+  for (const code of deck.extra ?? []) {
+    duel.newCard({
+      code,
+      owner,
+      playerId,
+      location: LOCATION_EXTRA,
+      sequence: 0,
+      position: POS_FACEDOWN_DEFENSE
+    });
+  }
+}
+function loadTagDeck(duel, deck, owner) {
+  if (!deck) return;
+  for (const code of deck.main ?? []) {
+    duel.newTagCard({
+      code,
+      owner,
+      location: LOCATION_DECK
+    });
+  }
+  for (const code of deck.extra ?? []) {
+    duel.newTagCard({
+      code,
+      owner,
+      location: LOCATION_EXTRA
+    });
+  }
+}
+function setRegistryValue(duel, key, value) {
+  duel.setRegistryValue(key, value);
+}
+var playYrp = (ocgcoreWrapper, yrpInput) => {
+  const yrp = normalizeYrp(yrpInput);
+  const messages = [];
+  const responses = yrp.responses.slice();
+  const duel = createReplayDuel(ocgcoreWrapper, yrp);
+  let ended = false;
+  const endDuel = () => {
+    if (ended) return;
+    duel.endDuel();
+    ended = true;
+  };
+  try {
+    setRegistryValue(duel, "duel_mode", yrp.isTag ? "tag" : "single");
+    setRegistryValue(duel, "start_lp", String(yrp.startLp));
+    setRegistryValue(duel, "start_hand", String(yrp.startHand));
+    setRegistryValue(duel, "draw_count", String(yrp.drawCount));
+    const playerNames = yrp.isTag ? [
+      yrp.hostName,
+      yrp.tagHostName ?? "",
+      yrp.tagClientName ?? "",
+      yrp.clientName
+    ] : [yrp.hostName, yrp.clientName];
+    for (let i = 0; i < playerNames.length; i++) {
+      setRegistryValue(duel, `player_name_${i}`, playerNames[i] ?? "");
+    }
+    setRegistryValue(duel, "player_type_0", "0");
+    setRegistryValue(duel, "player_type_1", "1");
+    duel.setPlayerInfo({
+      playerId: 0,
+      lp: yrp.startLp,
+      startCount: yrp.startHand,
+      drawCount: yrp.drawCount
+    });
+    duel.setPlayerInfo({
+      playerId: 1,
+      lp: yrp.startLp,
+      startCount: yrp.startHand,
+      drawCount: yrp.drawCount
+    });
+    duel.preloadScript("./script/patches/entry.lua");
+    duel.preloadScript("./script/special.lua");
+    duel.preloadScript("./script/init.lua");
+    if (yrp.isSingleMode && yrp.singleScript) {
+      duel.preloadScript(`./single/${yrp.singleScript}`);
+    } else if (yrp.isTag) {
+      loadDeck(duel, yrp.hostDeck, 0, 0);
+      loadTagDeck(duel, yrp.tagHostDeck, 0);
+      loadDeck(duel, yrp.clientDeck, 1, 1);
+      loadTagDeck(duel, yrp.tagClientDeck, 1);
+    } else {
+      loadDeck(duel, yrp.hostDeck, 0, 0);
+      loadDeck(duel, yrp.clientDeck, 1, 1);
+    }
+    duel.startDuel(yrp.opt >>> 0);
+    while (true) {
+      const { raw, status } = duel.process();
+      console.log(
+        "Duel process status:",
+        status,
+        "Message length:",
+        raw.length,
+        "Message:",
+        raw[0],
+        "Message string:",
+        Object.entries(OcgcoreCommonConstants).find(
+          ([k, v]) => v === raw[0] && k.startsWith("MSG_")
+        )?.[0] ?? "Unknown"
+      );
+      messages.push(raw);
+      if (raw.length > 0 && raw[0] === OcgcoreCommonConstants.MSG_RETRY) {
+        throw new Error("Got MSG_RETRY");
+      }
+      if (status === 0) {
+        continue;
+      }
+      if (status === 1) {
+        if (raw.length === 0) {
+          continue;
+        }
+        const response = responses.shift();
+        if (!response) {
+          break;
+        }
+        duel.setResponse(response);
+        continue;
+      }
+      break;
+    }
+  } finally {
+    endDuel();
+  }
+  return messages;
+};
+
+// index.ts
+if (typeof globalThis !== "undefined" && !globalThis.Buffer) {
+  globalThis.Buffer = import_buffer.Buffer;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CardDataStruct,
+  LEN_EMPTY,
+  LEN_FAIL,
+  LEN_HEADER,
+  MESSAGE_BUFFER_SIZE,
+  MapReader,
+  OcgcoreCommonConstants,
+  OcgcoreDuel,
+  OcgcoreDuelOptionFlag,
+  OcgcoreDuelRule,
+  OcgcoreMessageType,
+  OcgcoreScriptConstants,
+  OcgcoreWrapper,
+  QUERY_BUFFER_SIZE,
+  REGISTRY_BUFFER_SIZE,
+  ZipReader,
+  createOcgcoreWrapper,
+  createSqljsCardReader,
+  encodeUtf8,
+  normalizeStartDuelOptions,
+  parseCardQuery,
+  parseFieldCardQuery,
+  parseFieldInfo,
+  parseRegistryDump,
+  parseRegistryKeys,
+  playYrp,
+  readI32,
+  readU16,
+  readU32,
+  readU8
+});
+//# sourceMappingURL=index.cjs.map