board-game-engine 2.0.0 → 2.0.1

package/dist/board-game-engine.cjs

@@ -1,3 +1,4 @@
+"use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -5794,19 +5795,6 @@ var require_matches = __commonJS({
   }
 });
 
-// node_modules/lodash/cloneDeep.js
-var require_cloneDeep = __commonJS({
-  "node_modules/lodash/cloneDeep.js"(exports, module2) {
-    var baseClone = require_baseClone();
-    var CLONE_DEEP_FLAG = 1;
-    var CLONE_SYMBOLS_FLAG = 4;
-    function cloneDeep2(value2) {
-      return baseClone(value2, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);
-    }
-    module2.exports = cloneDeep2;
-  }
-});
-
 // node_modules/rfc6902/pointer.js
 var require_pointer = __commonJS({
   "node_modules/rfc6902/pointer.js"(exports) {
@@ -6487,7 +6475,7 @@ var require_setImmediate = __commonJS({
   }
 });
 
-// src/index.js
+// src/index.ts
 var index_exports = {};
 __export(index_exports, {
   Client: () => Client2,
@@ -6610,10 +6598,10 @@ function walkCyclical(value2, visitor, seen = /* @__PURE__ */ new WeakSet(), par
   return { duplicates, circular };
 }
 
-// src/game-factory/move/move-factory.js
+// src/game-factory/move/move-factory.ts
 var import_core2 = __toESM(require_core());
 
-// src/game-factory/entity.js
+// src/game-factory/entity.ts
 var Entity = class {
   constructor(options, rule, id) {
     if (!options?.fromBank) {
@@ -6641,10 +6629,10 @@ var Entity = class {
   }
 };
 
-// src/game-factory/space/space.js
+// src/game-factory/space/space.ts
 var Space = class extends Entity {
-  constructor(...args) {
-    super(...args);
+  constructor(options, rule, id) {
+    super(options, rule, id);
     this.entities = [];
   }
   placeEntity(entity, position = "Last") {
@@ -6667,24 +6655,27 @@ var Space = class extends Entity {
   }
 };
 
-// src/game-factory/board.js
+// src/game-factory/board.ts
 var Board = class extends Space {
 };
 
-// src/game-factory/space-group/space-group.js
+// src/game-factory/space-group/space-group.ts
 var SpaceGroup = class extends Entity {
-  constructor(options, ...rest) {
-    super(options, ...rest);
+  constructor(options, rule, id) {
+    super(options, rule, id);
     this.spaces = this.makeSpaces(options.bank);
   }
   makeSpaces(bank) {
-    return Array(this.getSpacesCount()).fill().map((_2, i2) => bank.createEntity({ entityType: "Space", index: i2 }));
+    return Array(this.getSpacesCount()).fill(void 0).map((_2, i2) => bank.createEntity({ entityType: "Space", index: i2 }));
   }
   getEmptySpaces() {
     return this.spaces.filter((space2) => space2.isEmpty());
   }
-  getSpace(index) {
-    return this.spaces[index];
+  getSpace(arg) {
+    if (Array.isArray(arg)) {
+      throw new Error("Numeric index only for SpaceGroup#getSpace");
+    }
+    return this.spaces[arg];
   }
   getEntities(index) {
     return this.getSpace(index).entities;
@@ -6692,9 +6683,12 @@ var SpaceGroup = class extends Entity {
   placeEntity(index, entity) {
     this.getSpace(index).placeEntity(entity);
   }
+  getSpacesCount() {
+    throw new Error("SpaceGroup#getSpacesCount must be implemented by subclass");
+  }
 };
 
-// src/game-factory/space-group/grid.js
+// src/game-factory/space-group/grid.ts
 var import_chunk = __toESM(require_chunk());
 var Grid = class extends SpaceGroup {
   getSpacesCount() {
@@ -6714,8 +6708,11 @@ var Grid = class extends SpaceGroup {
     const { width } = this.rule;
     return y2 * width + x2;
   }
-  getSpace(coordinates) {
-    return this.spaces[this.getIndex(coordinates)];
+  getSpace(arg) {
+    if (Array.isArray(arg)) {
+      return this.spaces[this.getIndex(arg)];
+    }
+    return this.spaces[arg];
   }
   getRelativeCoordinates([oldX, oldY], [relativeX, relativeY]) {
     const newCoordinates = [oldX + relativeX, oldY + relativeY];
@@ -6726,29 +6723,30 @@ var Grid = class extends SpaceGroup {
   }
 };
 
-// src/game-factory/bank/bank.js
+// src/game-factory/bank/bank.ts
 var import_find = __toESM(require_find());
 var import_filter = __toESM(require_filter());
 
-// src/utils/resolve-properties.js
+// src/utils/resolve-properties.ts
 var import_isPlainObject2 = __toESM(require_isPlainObject());
 var import_pick = __toESM(require_pick());
 
-// src/utils/get.js
+// src/utils/get.ts
 function get(obj, pathArray) {
   let current = obj;
   for (const step of pathArray) {
     if (current === void 0) {
       return current;
     }
-    if (step?.flatten) {
+    if (step && typeof step === "object" && "flatten" in step && step.flatten) {
       if (!Array.isArray(current)) {
         return void 0;
       }
-      current = current.flat();
+      let flat = current.flat();
       if (step.map) {
-        current = current.map((item) => get(item, step.map));
+        flat = flat.map((item) => get(item, step.map));
       }
+      current = flat;
     } else {
       current = current[step];
     }
@@ -8362,36 +8360,43 @@ Parser.prototype.isOperatorEnabled = function(op) {
   return !(optionName in operators) || !!operators[optionName];
 };
 
-// src/utils/resolve-expression.js
+// src/utils/resolve-expression.ts
 var parser = new Parser();
-parser.functions.sum = (array) => array.reduce((acc, val) => acc + val, 0);
+parser.functions.sum = (...args) => args[0].reduce((acc, val) => acc + val, 0);
 function resolveExpression2(bgioArguments, rule, context) {
   const args = resolveProperties(bgioArguments, rule.arguments, context);
   return parser.evaluate(rule.expression, args);
 }
 
-// src/utils/resolve-entity.js
+// src/utils/resolve-entity.ts
 var import_isPlainObject = __toESM(require_isPlainObject());
+
+// src/utils/bgio-resolve-types.ts
+function bankOf(bg) {
+  return bg.G.bank;
+}
+
+// src/utils/resolve-entity.ts
 var abstractTargetNames = ["state"];
 function resolveEntity(bgioArguments, target, context, targetName) {
-  return !abstractTargetNames.includes(targetName) && (0, import_isPlainObject.default)(target) ? bgioArguments.G.bank.find(bgioArguments, target, context) : target;
+  return !abstractTargetNames.includes(targetName ?? "") && (0, import_isPlainObject.default)(target) ? bankOf(bgioArguments).find(bgioArguments, target, context) : target;
 }
 
-// src/utils/resolve-properties.js
+// src/utils/resolve-properties.ts
 var resolutionTerminators = [
   "conditions",
   "move",
   "then",
   "mapping"
 ];
-function resolveProperties(bgioArguments, obj, context, key) {
+function resolveProperties(bgioArguments, obj, context = {}, key) {
   if (!(0, import_isPlainObject2.default)(obj) && !Array.isArray(obj)) {
     return obj;
   }
   let resolvedProperties = Array.isArray(obj) ? [...obj] : { ...obj };
-  Object.entries(obj).forEach(([key2, value2]) => {
-    if (!resolutionTerminators.includes(key2)) {
-      resolvedProperties[key2] = resolveProperties(bgioArguments, value2, context, key2);
+  Object.entries(obj).forEach(([k2, value2]) => {
+    if (!resolutionTerminators.includes(k2)) {
+      resolvedProperties[k2] = resolveProperties(bgioArguments, value2, context, k2);
     }
   });
   const resolved = resolveProperty(bgioArguments, resolvedProperties, context);
@@ -8404,45 +8409,47 @@ function resolveProperties(bgioArguments, obj, context, key) {
   ) : resolved;
 }
 function resolveProperty(bgioArguments, value2, context) {
-  if (value2?.type === "expression") {
+  const v2 = value2;
+  if (v2?.type === "expression") {
+    const expr = v2;
     return resolveExpression2(
       bgioArguments,
       {
-        ...value2,
-        arguments: resolveProperties(bgioArguments, value2.arguments, context, "arguments")
+        ...expr,
+        arguments: resolveProperties(bgioArguments, expr.arguments, context, "arguments")
       },
       context
     );
-  } else if (value2?.type === "count") {
-    return bgioArguments.G.bank.findAll(
+  } else if (v2?.type === "count") {
+    return bankOf(bgioArguments).findAll(
       bgioArguments,
       value2,
       context
     ).length;
-  } else if (value2?.type === "contextPath") {
-    return get(context, value2.path);
-  } else if (value2?.type === "ctxPath") {
-    return get(bgioArguments.ctx, value2.path);
-  } else if (value2?.type === "gamePath") {
-    return get(bgioArguments.G, value2.path);
-  } else if (value2?.type === "relativePath" || value2?.type === "RelativePath") {
-    const target = resolveProperties(bgioArguments, value2.target, context, "target");
-    return get(target.attributes, value2.path) ?? null;
-  } else if (value2?.type === "parent" || value2?.type === "Parent") {
-    const originalTarget = value2.target ? resolveProperties(bgioArguments, value2.target, context, "target") : context.originalTarget;
-    return bgioArguments.G.bank.findParent(originalTarget) ?? null;
-  } else if (value2?.type === "map") {
+  } else if (v2?.type === "contextPath") {
+    return get(context, v2.path);
+  } else if (v2?.type === "ctxPath") {
+    return get(bgioArguments.ctx, v2.path);
+  } else if (v2?.type === "gamePath") {
+    return get(bgioArguments.G, v2.path);
+  } else if (v2?.type === "relativePath" || v2?.type === "RelativePath") {
+    const target = resolveProperties(bgioArguments, v2.target, context, "target");
+    return get(target?.attributes, v2.path) ?? null;
+  } else if (v2?.type === "parent" || v2?.type === "Parent") {
+    const originalTarget = v2.target ? resolveProperties(bgioArguments, v2.target, context, "target") : context.originalTarget;
+    return bankOf(bgioArguments).findParent(originalTarget) ?? null;
+  } else if (v2?.type === "map") {
     return getMappedTargets(
       bgioArguments,
-      value2.targets,
-      value2.mapping,
+      v2.targets,
+      v2.mapping,
       context
     ).map((mappedTarget) => mappedTarget.value);
-  } else if (value2?.type === "mapMax") {
+  } else if (v2?.type === "mapMax") {
     const mappedTargets = getMappedTargets(
       bgioArguments,
-      value2.targets,
-      value2.mapping,
+      v2.targets,
+      v2.mapping,
       context
     );
     let maxValue;
@@ -8458,28 +8465,28 @@ function resolveProperty(bgioArguments, value2, context) {
       }
     }
     return maxTargets;
-  } else if (value2?.type === "pick" || value2?.type === "Pick") {
-    const target = resolveProperties(bgioArguments, value2.target, context, "target");
+  } else if (v2?.type === "pick" || v2?.type === "Pick") {
+    const target = resolveProperties(bgioArguments, v2.target, context, "target");
     return (0, import_pick.default)(
       resolveProperties(
         bgioArguments,
-        target.attributes,
+        target?.attributes,
         context,
         "attributes"
       ),
-      value2.properties
+      v2.properties
     );
-  } else if (value2?.type === "coordinates" || value2?.type === "Coordinates") {
-    const originalTarget = value2.target ? resolveProperties(bgioArguments, value2.target, context, "target") : context.originalTarget;
-    const parent = bgioArguments.G.bank.findParent(originalTarget);
+  } else if (v2?.type === "coordinates" || v2?.type === "Coordinates") {
+    const originalTarget = v2.target ? resolveProperties(bgioArguments, v2.target, context, "target") : context.originalTarget;
+    const parent = bankOf(bgioArguments).findParent(originalTarget);
     return parent.getCoordinates(originalTarget.rule.index);
-  } else if (value2?.type === "relativeCoordinates") {
-    const originalTarget = value2.target ? resolveProperties(bgioArguments, value2.target, context, "target") : context.originalTarget;
-    const parent = bgioArguments.G.bank.findParent(originalTarget);
+  } else if (v2?.type === "relativeCoordinates") {
+    const originalTarget = v2.target ? resolveProperties(bgioArguments, v2.target, context, "target") : context.originalTarget;
+    const parent = bankOf(bgioArguments).findParent(originalTarget);
     const oldCoordinates = parent.getCoordinates(originalTarget.rule.index);
     const newCoordinates = parent.getRelativeCoordinates(
       oldCoordinates,
-      resolveProperties(bgioArguments, value2.location, context, "location")
+      resolveProperties(bgioArguments, v2.location, context, "location")
     );
     return (newCoordinates && parent.spaces[parent.getIndex(newCoordinates)]) ?? null;
   } else {
@@ -8488,7 +8495,8 @@ function resolveProperty(bgioArguments, value2, context) {
 }
 function getMappedTargets(bgioArguments, targetsRule, mapping, context) {
   targetsRule.resolveAsEntity = true;
-  return resolveProperties(bgioArguments, targetsRule, context)?.map((target) => ({
+  const resolved = resolveProperties(bgioArguments, targetsRule, context);
+  return resolved?.map((target) => ({
     target,
     value: resolveProperties(
       bgioArguments,
@@ -8498,7 +8506,7 @@ function getMappedTargets(bgioArguments, targetsRule, mapping, context) {
   })) ?? [];
 }
 
-// src/game-factory/condition/condition.js
+// src/game-factory/condition/condition.ts
 var Condition = class {
   constructor(rule) {
     this.rule = rule;
@@ -8523,11 +8531,15 @@ var Condition = class {
     return this.checkCondition(bgioArguments, rule, conditionPayload, newContext);
   }
   isMet(...args) {
-    return this.check(...args).conditionIsMet;
+    return this.check(
+      args[0],
+      args[1] ?? {},
+      args[2] ?? {}
+    ).conditionIsMet;
   }
 };
 
-// src/utils/entity-matches.js
+// src/utils/entity-matches.ts
 var import_matches = __toESM(require_matches());
 function resolveMatcher(bgioArguments, matcher, context) {
   const resolvedMatcher = { ...matcher };
@@ -8545,7 +8557,7 @@ function entityMatches(bgioArguments, matcher, entity, context) {
   return (0, import_matches.default)(resolveMatcher(bgioArguments, matcher, context))(getEntityMatcher(entity));
 }
 
-// src/game-factory/condition/is-condition.js
+// src/game-factory/condition/is-condition.ts
 var Is = class extends Condition {
   checkCondition(bgioArguments, rule, { target }, context) {
     if (this.rule.entity && target !== rule.entity) {
@@ -8566,12 +8578,12 @@ var Is = class extends Condition {
   }
 };
 
-// src/game-factory/condition/not-condition.js
+// src/game-factory/condition/not-condition.ts
 var NotCondition = class extends Condition {
   checkCondition(bgioArguments, rule, payload, context) {
     const result = checkConditions(
       bgioArguments,
-      rule,
+      rule.conditions,
       payload,
       context
     );
@@ -8579,8 +8591,8 @@ var NotCondition = class extends Condition {
   }
 };
 
-// src/utils/find-met-condition.js
-function findMetCondition(bgioArguments, { conditions = [] }, payload, context) {
+// src/utils/find-met-condition.ts
+function findMetCondition(bgioArguments, conditions = [], payload, context) {
   let success;
   for (const conditionRule of conditions) {
     const result = conditionFactory(conditionRule).check(bgioArguments, payload, context);
@@ -8595,12 +8607,12 @@ function findMetCondition(bgioArguments, { conditions = [] }, payload, context)
   return success;
 }
 
-// src/game-factory/condition/or-condition.js
+// src/game-factory/condition/or-condition.ts
 var Or = class extends Condition {
   checkCondition(bgioArguments, rule, payload, context) {
     const result = findMetCondition(
       bgioArguments,
-      rule,
+      rule.conditions,
       payload,
       context
     );
@@ -8608,9 +8620,10 @@ var Or = class extends Condition {
   }
 };
 
-// src/game-factory/condition/some-condition.js
+// src/game-factory/condition/some-condition.ts
 var SomeCondition = class extends Condition {
-  checkCondition(bgioArguments, rule, { target: targets }, context) {
+  checkCondition(bgioArguments, rule, conditionPayload, context) {
+    const targets = conditionPayload.target;
     const result = targets.find((target) => {
       const loopContext = {
         ...context,
@@ -8618,7 +8631,7 @@ var SomeCondition = class extends Condition {
       };
       return checkConditions(
         bgioArguments,
-        rule,
+        rule.conditions,
         void 0,
         loopContext
       ).conditionsAreMet;
@@ -8630,9 +8643,10 @@ var SomeCondition = class extends Condition {
   }
 };
 
-// src/game-factory/condition/every-condition.js
+// src/game-factory/condition/every-condition.ts
 var EveryCondition = class extends Condition {
-  checkCondition(bgioArguments, rule, { target: targets }, context) {
+  checkCondition(bgioArguments, rule, conditionPayload, context) {
+    const targets = conditionPayload.target;
     const results = targets.map((target) => {
       const loopContext = {
         ...context,
@@ -8640,7 +8654,7 @@ var EveryCondition = class extends Condition {
       };
       return checkConditions(
         bgioArguments,
-        rule,
+        rule.conditions,
         void 0,
         loopContext
       );
@@ -8652,18 +8666,18 @@ var EveryCondition = class extends Condition {
   }
 };
 
-// src/game-factory/condition/contains-condition.js
+// src/game-factory/condition/contains-condition.ts
 var import_matches2 = __toESM(require_matches());
 var ContainsCondition = class extends Condition {
   checkCondition(bgioArguments, rule, payload, context) {
-    const { target } = payload;
+    const target = payload.target;
     if (!target) {
       return { matches: [], conditionIsMet: false };
     } else {
       const candidates = target.entities ?? target.spaces;
       const matches2 = candidates?.filter((entity) => checkConditions(
         bgioArguments,
-        rule,
+        rule.conditions,
         { target: entity },
         context
       ).conditionsAreMet) ?? [];
@@ -8672,22 +8686,25 @@ var ContainsCondition = class extends Condition {
   }
 };
 
-// src/game-factory/condition/contains-same-condition.js
+// src/game-factory/condition/contains-same-condition.ts
 var import_pick2 = __toESM(require_pick());
 var ContainsSame = class extends Condition {
-  checkCondition(bgioArguments, rule, { targets }) {
+  checkCondition(bgioArguments, rule, conditionPayload, _newContext) {
+    const { targets } = conditionPayload;
     if (targets.length === 1 && targets[0].entities?.length) {
       return { conditionIsMet: true };
     }
     const [first, ...restEntities] = targets;
-    const conditionIsMet = first.entities.some((entity) => {
+    const conditionIsMet = (first.entities ?? []).some((entity) => {
+      const e = entity;
       const condition2 = conditionFactory({
         conditionType: "Contains",
         conditions: [{
           conditionType: "Is",
-          matcher: (0, import_pick2.default)(entity.rule, rule.properties)
+          matcher: (0, import_pick2.default)(e.rule, rule.properties)
         }]
       });
+      if (!condition2) return false;
       return restEntities.every((ent) => {
         return condition2.isMet(bgioArguments, { target: ent });
       });
@@ -8696,7 +8713,7 @@ var ContainsSame = class extends Condition {
   }
 };
 
-// src/utils/grid-contains-sequence.js
+// src/utils/grid-contains-sequence.ts
 var import_matches3 = __toESM(require_matches());
 var directions = [
   [1, 0],
@@ -8815,12 +8832,9 @@ function tryMatchSequence(bgioArguments, lineSpaces, startIndex, sequencePattern
   return matchedSpaces.length > 0 ? matchedSpaces : null;
 }
 function checkSpaceConditions(bgioArguments, space2, conditions, chunkMatches = [], context) {
-  if (!conditions || conditions.length === 0) {
-    return true;
-  }
   return checkConditions(
     bgioArguments,
-    { conditions },
+    conditions,
     {
       target: space2,
       targets: [space2, ...chunkMatches]
@@ -8869,13 +8883,18 @@ function gridContainsSequence(bgioArguments, grid, sequencePattern, context) {
   return result;
 }
 
-// src/game-factory/condition/in-line-condition.js
+// src/game-factory/condition/in-line-condition.ts
 var InLineCondition = class extends Condition {
   checkCondition(bgioArguments, rule, payload, context) {
     const { G: G2 } = bgioArguments;
     const { target } = payload;
     const parent = G2.bank.findParent(payload.target);
-    const { matches: allMatches } = gridContainsSequence(bgioArguments, parent, rule.sequence, context);
+    const { matches: allMatches } = gridContainsSequence(
+      bgioArguments,
+      parent,
+      rule.sequence,
+      context
+    );
     const matches2 = allMatches.filter(
       (sequence) => sequence.some((space2) => space2 === target)
     );
@@ -8883,7 +8902,7 @@ var InLineCondition = class extends Condition {
   }
 };
 
-// src/game-factory/condition/has-line-condition.js
+// src/game-factory/condition/has-line-condition.ts
 var HasLineCondition = class extends Condition {
   checkCondition(bgioArguments, rule, payload, context) {
     const { matches: matches2 } = gridContainsSequence(
@@ -8896,16 +8915,17 @@ var HasLineCondition = class extends Condition {
   }
 };
 
-// src/game-factory/condition/is-full-condition.js
+// src/game-factory/condition/is-full-condition.ts
 var IsFull = class extends Condition {
-  checkCondition(bgioArguments, rule, payload, context) {
+  checkCondition(_bgioArguments, _rule, payload, _context) {
+    const t2 = payload.target;
     return {
-      conditionIsMet: payload.target.spaces.every((space2) => space2?.entities.length)
+      conditionIsMet: t2.spaces.every((space2) => space2?.entities?.length)
     };
   }
 };
 
-// src/utils/simulate-move.js
+// src/utils/simulate-move.ts
 function simulateMove(bgioArguments, payload, context) {
   const simulatedG = deserialize(serialize(bgioArguments.G), registry);
   const newBgioArguments = {
@@ -8925,7 +8945,7 @@ function simulateMove(bgioArguments, payload, context) {
   return simulatedG;
 }
 
-// src/game-factory/condition/would-condition.js
+// src/game-factory/condition/would-condition.ts
 var argNameMap = {
   PlaceNew: ["destination"],
   RemoveEntity: ["entity"],
@@ -8934,12 +8954,16 @@ var argNameMap = {
   SetState: ["entity", "state"]
 };
 var WouldCondition = class extends Condition {
-  checkCondition(bgioArguments, rule, { target, targets = [target] }, context) {
+  checkCondition(bgioArguments, rule, conditionPayload, context) {
+    const target = conditionPayload.target;
+    const targets = conditionPayload.targets ?? [target];
+    const moveType = context.moveInstance?.rule?.moveType;
+    const argNames = moveType ? argNameMap[moveType] : void 0;
     const payload = {
-      arguments: targets.reduce((acc, target2, i2) => ({
-        ...acc,
-        [argNameMap[context.moveInstance.rule.moveType][i2]]: target2
-      }), {})
+      arguments: targets.reduce((acc, t2, i2) => {
+        const key = argNames?.[i2] ?? `arg${i2}`;
+        return { ...acc, [key]: t2 };
+      }, {})
     };
     const simulatedG = simulateMove(
       bgioArguments,
@@ -8957,11 +8981,8 @@ var WouldCondition = class extends Condition {
       };
     }
     const conditionResults = checkConditions(
-      {
-        ...bgioArguments,
-        G: simulatedG
-      },
-      rule,
+      { ...bgioArguments, G: simulatedG },
+      rule.conditions,
       simulatedConditionsPayload,
       context
     );
@@ -8989,26 +9010,26 @@ function restoreReferences(obj, getOriginalEntity, seen = /* @__PURE__ */ new We
   }
   if (Array.isArray(obj)) {
     return obj.map((item) => restoreReferences(item, getOriginalEntity, seen));
-  } else {
-    const restored = {};
-    for (const key in obj) {
-      if (obj.hasOwnProperty(key)) {
-        restored[key] = restoreReferences(obj[key], getOriginalEntity, seen);
-      }
+  }
+  const restored = {};
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      restored[key] = restoreReferences(obj[key], getOriginalEntity, seen);
     }
-    return restored;
   }
+  return restored;
 }
 
-// src/utils/any-valid-moves.js
+// src/utils/any-valid-moves.ts
 var import_isPlainObject3 = __toESM(require_isPlainObject());
 function findMoveArgumentReferences(obj, refs = /* @__PURE__ */ new Set()) {
   if (!obj || typeof obj !== "object") {
     return refs;
   }
-  if (obj.type === "contextPath" && Array.isArray(obj.path)) {
-    if (obj.path[0] === "moveArguments" && obj.path[1]) {
-      refs.add(obj.path[1]);
+  const o2 = obj;
+  if (o2.type === "contextPath" && Array.isArray(o2.path)) {
+    if (o2.path[0] === "moveArguments" && o2.path[1]) {
+      refs.add(String(o2.path[1]));
     }
   }
   for (const value2 of Object.values(obj)) {
@@ -9082,21 +9103,23 @@ function findValidCombination(bgioArguments, moveInstance, ruleArguments, ordere
   });
 }
 function areThereValidMoves(bgioArguments, moves) {
+  const bgio = bgioArguments;
   return Object.values(moves).some((move) => {
-    const { moveInstance } = move;
+    const moveInstance = move?.moveInstance;
+    if (!moveInstance) return false;
     const context = { moveInstance };
     const rule = resolveProperties(
-      bgioArguments,
+      bgio,
       moveInstance.rule,
       context
     );
     const ruleArguments = rule.arguments ?? {};
     if (Object.keys(ruleArguments).length === 0) {
-      return moveInstance.isValid(bgioArguments, { arguments: {} }, context);
+      return moveInstance.isValid(bgio, { arguments: {} }, context);
     }
     const orderedArgNames = getArgumentOrder(ruleArguments);
     return findValidCombination(
-      bgioArguments,
+      bgio,
       moveInstance,
       ruleArguments,
       orderedArgNames,
@@ -9105,18 +9128,19 @@ function areThereValidMoves(bgioArguments, moves) {
   });
 }
 
-// src/utils/get-current-moves.js
-function getCurrentMoves(state, { game, playerID, stageName }) {
+// src/utils/get-current-moves.ts
+function getCurrentMoves(state, client) {
+  const { game, playerID, stageName } = client;
   const phaseName = state.ctx.phase;
-  const stageNameToUse = stageName ?? state.ctx.activePlayers?.[playerID ?? state.ctx.currentPlayer];
+  const stageNameToUse = stageName ?? state.ctx.activePlayers?.[playerID ?? state.ctx.currentPlayer ?? ""];
   const phaseOrRoot = game.phases?.[phaseName] ?? game;
   const stageOrPhaseOrRoot = phaseOrRoot.turn?.stages?.[stageNameToUse] ?? phaseOrRoot;
   return stageOrPhaseOrRoot.moves ?? {};
 }
 
-// src/game-factory/condition/no-possible-moves-condition.js
+// src/game-factory/condition/no-possible-moves-condition.ts
 var NoPossibleMoves = class extends Condition {
-  checkCondition(bgioArguments, _2, __, context) {
+  checkCondition(bgioArguments, _unused, _payload, context) {
     return {
       conditionIsMet: !areThereValidMoves(
         bgioArguments,
@@ -9126,7 +9150,7 @@ var NoPossibleMoves = class extends Condition {
   }
 };
 
-// src/game-factory/condition/evaluate-condition.js
+// src/game-factory/condition/evaluate-condition.ts
 var import_matches4 = __toESM(require_matches());
 var Evaluate = class extends Condition {
   checkCondition(bgioArguments, rule, payload, context) {
@@ -9143,11 +9167,12 @@ var Evaluate = class extends Condition {
   }
 };
 
-// src/game-factory/condition/position-condition.js
+// src/game-factory/condition/position-condition.ts
 var Position = class extends Condition {
-  checkCondition(bgioArguments, rule, { target }) {
+  checkCondition(bgioArguments, rule, conditionPayload, _newContext) {
+    const target = conditionPayload.target;
     const parent = bgioArguments.G.bank.findParent(target);
-    let conditionIsMet;
+    let conditionIsMet = false;
     if (rule.position === "First") {
       conditionIsMet = parent.entities.indexOf(target) === 0;
     }
@@ -9155,42 +9180,46 @@ var Position = class extends Condition {
   }
 };
 
-// src/game-factory/condition/condition-factory.js
+// src/game-factory/condition/condition-factory.ts
 function conditionFactory(rule) {
-  if (rule.conditionType === "Is") {
-    return new Is(rule);
-  } else if (rule.conditionType === "Not") {
-    return new NotCondition(rule);
-  } else if (rule.conditionType === "Or") {
-    return new Or(rule);
-  } else if (rule.conditionType === "Some") {
-    return new SomeCondition(rule);
-  } else if (rule.conditionType === "Contains") {
-    return new ContainsCondition(rule);
-  } else if (rule.conditionType === "ContainsSame") {
-    return new ContainsSame(rule);
-  } else if (rule.conditionType === "Every") {
-    return new EveryCondition(rule);
-  } else if (rule.conditionType === "InLine") {
-    return new InLineCondition(rule);
-  } else if (rule.conditionType === "HasLine") {
-    return new HasLineCondition(rule);
-  } else if (rule.conditionType === "IsFull") {
-    return new IsFull(rule);
-  } else if (rule.conditionType === "Would") {
-    return new WouldCondition(rule);
-  } else if (rule.conditionType === "NoPossibleMoves") {
-    return new NoPossibleMoves(rule);
-  } else if (rule.conditionType === "Evaluate") {
-    return new Evaluate(rule);
-  } else if (rule.conditionType === "Position") {
-    return new Position(rule);
-  }
-}
-
-// src/utils/check-conditions.js
-function checkConditions(bgioArguments, rule, payload, context) {
-  const { conditions = [] } = rule;
+  if (typeof rule !== "object" || rule === null || !("conditionType" in rule)) {
+    return void 0;
+  }
+  const r2 = rule;
+  if (r2.conditionType === "Is") {
+    return new Is(r2);
+  } else if (r2.conditionType === "Not") {
+    return new NotCondition(r2);
+  } else if (r2.conditionType === "Or") {
+    return new Or(r2);
+  } else if (r2.conditionType === "Some") {
+    return new SomeCondition(r2);
+  } else if (r2.conditionType === "Contains") {
+    return new ContainsCondition(r2);
+  } else if (r2.conditionType === "ContainsSame") {
+    return new ContainsSame(r2);
+  } else if (r2.conditionType === "Every") {
+    return new EveryCondition(r2);
+  } else if (r2.conditionType === "InLine") {
+    return new InLineCondition(r2);
+  } else if (r2.conditionType === "HasLine") {
+    return new HasLineCondition(r2);
+  } else if (r2.conditionType === "IsFull") {
+    return new IsFull(r2);
+  } else if (r2.conditionType === "Would") {
+    return new WouldCondition(r2);
+  } else if (r2.conditionType === "NoPossibleMoves") {
+    return new NoPossibleMoves(r2);
+  } else if (r2.conditionType === "Evaluate") {
+    return new Evaluate(r2);
+  } else if (r2.conditionType === "Position") {
+    return new Position(r2);
+  }
+  return void 0;
+}
+
+// src/utils/check-conditions.ts
+function checkConditions(bgioArguments, conditions = [], payload = {}, context = {}) {
   const results = [];
   let failedAt;
   for (const conditionRule of conditions) {
@@ -9209,18 +9238,18 @@ function checkConditions(bgioArguments, rule, payload, context) {
   };
 }
 
-// src/game-factory/bank/bank-slot.js
+// src/game-factory/bank/bank-slot.ts
 var BankSlot = class {
   constructor(rule, bank) {
     this.bank = bank;
     this.rule = rule;
     this.pool = [];
-    this.remaining = +rule.count || 1;
+    this.remaining = +(rule.count || 1);
   }
   getOne(bgioArguments, options, context) {
     return this.getMultiple(bgioArguments, 1, options, context)[0];
   }
-  getMultiple(bgioArguments, count = Infinity, options = {}, context) {
+  getMultiple(bgioArguments, count = Infinity, options = {}, context = {}) {
     const toReturn = [];
     if (this.remaining === Infinity && count === Infinity) {
       throw new Error(`Cannot get infinite pieces from slot with infinite remaining: ${this.rule.name}`);
@@ -9245,7 +9274,10 @@ var BankSlot = class {
     if (options.state) {
       const newState = resolveProperties(bgioArguments, options.state, context);
       toReturn.forEach((entity) => {
-        entity.state = { ...entity.state, ...newState };
+        entity.state = {
+          ...entity.state,
+          ...newState
+        };
       });
     }
     return toReturn;
@@ -9264,7 +9296,7 @@ var BankSlot = class {
 };
 var bank_slot_default = BankSlot;
 
-// src/game-factory/bank/bank.js
+// src/game-factory/bank/bank.ts
 var Bank = class {
   constructor(entityRules) {
     this.currentEntityId = 0;
@@ -9272,7 +9304,8 @@ var Bank = class {
     this.slots = entityRules.map((rule) => new bank_slot_default(rule, this));
   }
   createEntity(definition = {}, options) {
-    const entity = new registry[definition.entityType || "Entity"](
+    const Ctor = registry[definition.entityType || "Entity"];
+    const entity = new Ctor(
       {
         bank: this,
         fromBank: true,
@@ -9298,7 +9331,7 @@ var Bank = class {
       Object.values(this.tracker),
       (entity) => checkConditions(
         bgioArguments,
-        rule,
+        rule.conditions,
         { target: entity },
         context
       ).conditionsAreMet
@@ -9337,7 +9370,7 @@ var Bank = class {
     return this.slots.find(
       (slot) => checkConditions(
         bgioArguments,
-        rule,
+        rule.conditions,
         { target: slot },
         context
       ).conditionsAreMet
@@ -9347,7 +9380,7 @@ var Bank = class {
     return this.slots.filter(
       (slot) => checkConditions(
         bgioArguments,
-        rule,
+        rule.conditions,
         { target: slot },
         context
       ).conditionsAreMet
@@ -9355,13 +9388,13 @@ var Bank = class {
   }
   returnToBank(bgioArguments, entity) {
     this.findParent(entity).remove(entity);
-    this.getSlot(bgioArguments, entity.rule).returnToBank(entity);
+    this.getSlot(bgioArguments, entity.rule, {}).returnToBank(entity);
     delete this.tracker[entity.entityId];
   }
 };
 var bank_default = Bank;
 
-// src/registry.js
+// src/registry.ts
 var registry = {
   Board,
   SpaceGroup,
@@ -9372,7 +9405,7 @@ var registry = {
   Entity
 };
 
-// src/utils/deserialize-bgio-arguments.js
+// src/utils/deserialize-bgio-arguments.ts
 function deserializeBgioArguments(bgioArguments) {
   return {
     ...bgioArguments,
@@ -9380,14 +9413,15 @@ function deserializeBgioArguments(bgioArguments) {
   };
 }
 
-// src/game-factory/move/move.js
+// src/game-factory/move/move.ts
 var import_core = __toESM(require_core());
 var Move = class {
   constructor(rule) {
     this.rule = this.transformRule(rule);
   }
   checkValidity(bgioArguments, payload, context) {
-    const argRuleEntries = Object.entries(this.rule.arguments ?? {});
+    const moveArguments = "arguments" in this.rule && this.rule.arguments ? this.rule.arguments : {};
+    const argRuleEntries = Object.entries(moveArguments);
     if (!argRuleEntries.every(([argName]) => {
       const arg = payload.arguments[argName];
       return arg !== void 0 && (!Array.isArray(arg) || arg.length);
@@ -9400,11 +9434,11 @@ var Move = class {
       const payloadArg = payload.arguments[argName];
       const args = Array.isArray(payloadArg) ? payloadArg : [payloadArg];
       const argResults = [];
-      for (let j2 = 0, len2 = args.length; j2 < len2; j2++) {
+      for (let j2 = 0, lenj = args.length; j2 < lenj; j2++) {
         const arg = args[j2];
         const result = checkConditions(
           bgioArguments,
-          argRule,
+          argRule.conditions,
           { target: arg },
           { ...context, moveArguments: payload.arguments }
         );
@@ -9413,7 +9447,8 @@ var Move = class {
           break;
         }
       }
-      const argConditionsAreMet = argResults.at(-1).conditionsAreMet;
+      const last = argResults[argResults.length - 1];
+      const argConditionsAreMet = last?.conditionsAreMet ?? false;
       argumentResults[argName] = {
         results: argResults,
         conditionsAreMet: argConditionsAreMet
@@ -9424,8 +9459,8 @@ var Move = class {
     }
     const moveResults = checkConditions(
       bgioArguments,
-      { conditions: this.rule.conditions },
-      void 0,
+      this.rule.conditions,
+      {},
       { ...context, moveArguments: payload.arguments }
     );
     return {
@@ -9440,6 +9475,7 @@ var Move = class {
       payload,
       context
     );
+    if (conditionResults === false) return false;
     return conditionResults.conditionsAreMet;
   }
   doMove(bgioArguments, payload, context, { skipCheck = false } = {}) {
@@ -9450,12 +9486,10 @@ var Move = class {
     );
     const resolvedPayload = {
       ...payload,
-      arguments: Object.entries(rule.arguments ?? {}).reduce((acc, [argName, arg]) => {
-        return {
-          ...acc,
-          [argName]: payload?.arguments?.[argName] ?? arg
-        };
-      }, {})
+      arguments: Object.entries(rule.arguments ?? {}).reduce((acc, [argName, arg]) => ({
+        ...acc,
+        [argName]: payload?.arguments?.[argName] ?? arg
+      }), {})
     };
     if (rule.name) {
       bgioArguments.G._meta.previousPayloads[rule.name] = resolvedPayload;
@@ -9464,7 +9498,7 @@ var Move = class {
     if (!skipCheck) {
       conditionResults = this.checkValidity(bgioArguments, resolvedPayload, context);
     }
-    if (!skipCheck && !conditionResults.conditionsAreMet) {
+    if (!skipCheck && conditionResults !== false && !conditionResults.conditionsAreMet) {
       return import_core.INVALID_MOVE;
     } else {
       this.do(bgioArguments, rule, resolvedPayload, context);
@@ -9474,81 +9508,100 @@ var Move = class {
     }
     return { conditionResults };
   }
+  do(_bgioArguments, _rule, _resolvedPayload, _context) {
+    throw new Error("Move#do must be implemented by subclass");
+  }
   transformRule(rule) {
     const args = rule.arguments;
-    for (let key in args) {
-      const arg = args[key];
-      if (!arg.playerChoice) {
-        arg.resolveAsEntity = true;
+    if (args) {
+      for (const key in args) {
+        const arg = args[key];
+        if (arg && !arg.playerChoice) {
+          arg.resolveAsEntity = true;
+        }
       }
     }
     return rule;
   }
 };
 
-// src/game-factory/move/move-entity.js
+// src/game-factory/move/move-entity.ts
 var MoveEntity = class extends Move {
-  do(bgioArguments, rule, { arguments: { entity, destination } }) {
+  do(bgioArguments, rule, resolvedPayload) {
+    const { entity, destination } = resolvedPayload.arguments;
+    const g2 = bgioArguments;
     if (Array.isArray(entity)) {
       entity.forEach((e) => {
-        bgioArguments.G.bank.findParent(e)?.remove(e);
+        g2.G.bank.findParent(e)?.remove(e);
         destination.placeEntity(e, rule.position);
       });
     } else {
-      bgioArguments.G.bank.findParent(entity)?.remove(entity);
+      g2.G.bank.findParent(entity)?.remove(entity);
       destination.placeEntity(entity, rule.position);
     }
   }
 };
 
-// src/game-factory/move/remove-entity.js
+// src/game-factory/move/remove-entity.ts
 var RemoveEntity = class extends Move {
-  do(bgioArguments, rule, { arguments: { entity } }) {
-    bgioArguments.G.bank.returnToBank(bgioArguments, entity);
+  do(bgioArguments, _rule, resolvedPayload) {
+    const { entity } = resolvedPayload.arguments;
+    const bgio = bgioArguments;
+    bankOf(bgio).returnToBank(bgio, entity);
   }
 };
 
-// src/game-factory/move/place-new.js
+// src/game-factory/move/place-new.ts
 var PlaceNew = class extends Move {
-  do(bgioArguments, rule, { arguments: { destination } }, context) {
-    const entities = rule.matchMultiple ? bgioArguments.G.bank.getMultiple(
-      bgioArguments,
+  do(bgioArguments, rule, resolvedPayload, context) {
+    const { destination } = resolvedPayload.arguments;
+    const bgio = bgioArguments;
+    const r2 = rule;
+    const bank = bankOf(bgio);
+    const entities = r2.matchMultiple ? bank.getMultiple(
+      bgio,
       {
-        ...rule.entity,
+        ...r2.entity,
         conditions: [
-          ...rule.entity?.conditions || [],
-          ...rule.conditions || []
+          ...r2.entity?.conditions || [],
+          ...r2.conditions || []
         ]
       },
-      rule.count,
+      r2.count ?? 1,
       context
-    ) : [bgioArguments.G.bank.getOne(
-      bgioArguments,
+    ) : [bank.getOne(
+      bgio,
       {
-        ...rule.entity,
+        ...r2.entity,
         conditions: [
-          ...rule.entity?.conditions || [],
-          ...rule.conditions || []
+          ...r2.entity?.conditions || [],
+          ...r2.conditions || []
         ]
       },
       context
     )];
     entities.forEach((entity) => {
-      destination.placeEntity(entity, rule.position);
+      destination.placeEntity(entity, r2.position);
     });
   }
 };
 
-// src/game-factory/move/take-from.js
+// src/game-factory/move/take-from.ts
 var TakeFrom = class extends Move {
-  do(bgioArguments, rule, { arguments: { source, destination } }) {
-    destination.placeEntity(source.takeOne(rule.arguments.source.position));
+  do(_bgioArguments, rule, resolvedPayload) {
+    const { source, destination } = resolvedPayload.arguments;
+    destination.placeEntity(
+      source.takeOne(
+        rule.arguments.source.position
+      )
+    );
   }
 };
 
-// src/game-factory/move/set-state.js
+// src/game-factory/move/set-state.ts
 var SetState = class extends Move {
-  do(_2, __, { arguments: { entity, state } }) {
+  do(_unused, _rule, resolvedPayload) {
+    const { entity, state } = resolvedPayload.arguments;
     entity.state = {
       ...entity.state,
       [state.property]: state.value
@@ -9556,7 +9609,7 @@ var SetState = class extends Move {
   }
 };
 
-// src/utils/do-moves.js
+// src/utils/do-moves.ts
 function doMoves(bgioArguments, moves = [], context) {
   if (!moves?.length) {
     return bgioArguments.G;
@@ -9571,11 +9624,12 @@ function doMoves(bgioArguments, moves = [], context) {
   return bgioArguments.G;
 }
 
-// src/game-factory/move/set-active-players.js
+// src/game-factory/move/set-active-players.ts
 var SetActivePlayers = class extends Move {
-  do(bgioArguments, rule, _2, context) {
-    bgioArguments.events.setActivePlayers(rule.options);
-    const phaseName = bgioArguments.ctx.phase;
+  do(bgioArguments, rule, _unused, context) {
+    const b2 = bgioArguments;
+    b2.events.setActivePlayers(rule.options);
+    const phaseName = b2.ctx.phase;
     const stageName = rule.options.currentPlayer?.stage;
     const phaseOrRoot = context.game.phases?.[phaseName] ?? context.game;
     const stage = phaseOrRoot?.turn?.stages?.[stageName];
@@ -9590,26 +9644,28 @@ var SetActivePlayers = class extends Move {
   }
 };
 
-// src/game-factory/move/end-turn.js
+// src/game-factory/move/end-turn.ts
 var EndTurn = class extends Move {
   do(bgioArguments) {
     bgioArguments.events.endTurn();
   }
 };
 
-// src/game-factory/move/pass-turn.js
+// src/game-factory/move/pass-turn.ts
 var PassTurn = class extends Move {
   do(bgioArguments) {
-    if (bgioArguments.G._meta.passedPlayers.length < bgioArguments.ctx.numPlayers) {
-      bgioArguments.G._meta.passedPlayers.push(bgioArguments.ctx.currentPlayer);
-      bgioArguments.events.pass();
+    const a2 = bgioArguments;
+    if (a2.G._meta.passedPlayers.length < a2.ctx.numPlayers) {
+      a2.G._meta.passedPlayers.push(a2.ctx.currentPlayer);
+      a2.events.pass();
     }
   }
 };
 
-// src/game-factory/move/for-each.js
+// src/game-factory/move/for-each.ts
 var ForEach = class extends Move {
-  do(bgioArguments, rule, { arguments: { targets } }, context) {
+  do(bgioArguments, rule, resolvedPayload, context) {
+    const { targets } = resolvedPayload.arguments;
     targets.forEach((target) => {
       const loopContext = {
         ...context,
@@ -9624,23 +9680,28 @@ var ForEach = class extends Move {
   }
 };
 
-// src/game-factory/move/pass.js
+// src/game-factory/move/pass.ts
 var Pass = class extends Move {
   do(bgioArguments) {
     bgioArguments.events.endTurn();
   }
 };
 
-// src/game-factory/move/shuffle.js
+// src/game-factory/move/shuffle.ts
 var Shuffle = class extends Move {
-  do(bgioArguments, _2, { arguments: { target } }) {
-    target.entities = bgioArguments.random.Shuffle(target.entities);
+  do(bgioArguments, _rule, resolvedPayload) {
+    const { target } = resolvedPayload.arguments;
+    const b2 = bgioArguments;
+    target.entities = b2.random.Shuffle(target.entities);
   }
 };
 
-// src/game-factory/move/move-factory.js
+// src/game-factory/move/move-factory.ts
 function moveFactory(moveRule, game) {
   const moveInstance = getMoveInstance(moveRule);
+  if (!moveInstance) {
+    throw new Error("moveFactory: unknown moveType");
+  }
   const compatibleMove = function(bgioArguments, serializablePayload) {
     const newBgioArguments = deserializeBgioArguments(bgioArguments);
     const { G: G2 } = newBgioArguments;
@@ -9649,8 +9710,10 @@ function moveFactory(moveRule, game) {
     const moveConditionResults = moveInstance.doMove(newBgioArguments, payload, context);
     context.moveConditionResults = [moveConditionResults];
     if (moveConditionResults !== import_core2.INVALID_MOVE && moveRule.then) {
-      for (let automaticMoveRule of moveRule.then) {
-        const result = getMoveInstance(automaticMoveRule).doMove(
+      for (const automaticMoveRule of moveRule.then) {
+        const auto = getMoveInstance(automaticMoveRule);
+        if (!auto) continue;
+        const result = auto.doMove(
           newBgioArguments,
           {},
           { ...context }
@@ -9665,16 +9728,15 @@ function moveFactory(moveRule, game) {
   return compatibleMove;
 }
 function revivePayload(serializablePayload, G2) {
-  if (serializablePayload) {
-    const payload = deserialize(JSON.stringify(serializablePayload), registry);
-    payload.arguments = Object.entries(payload.arguments).reduce((acc, [key, argOrEntityId]) => ({
-      ...acc,
-      [key]: typeof argOrEntityId === "number" ? G2.bank.locate(argOrEntityId) : argOrEntityId
-    }), {});
-    return payload;
-  } else {
-    return serializablePayload;
+  if (!serializablePayload) {
+    return void 0;
   }
+  const payload = deserialize(JSON.stringify(serializablePayload), registry);
+  payload.arguments = Object.entries(payload.arguments).reduce((acc, [key, argOrEntityId]) => ({
+    ...acc,
+    [key]: typeof argOrEntityId === "number" ? G2.bank.locate(argOrEntityId) : argOrEntityId
+  }), {});
+  return payload;
 }
 function getMoveInstance(moveRule) {
   switch (moveRule.moveType) {
@@ -9703,13 +9765,12 @@ function getMoveInstance(moveRule) {
   }
 }
 
-// src/game-factory/expand-game-rules.js
-var import_cloneDeep = __toESM(require_cloneDeep());
+// src/game-factory/expand-game-rules.ts
 var import_find2 = __toESM(require_find());
 
-// src/utils/json-transformer.js
+// src/utils/json-transformer.ts
 function transformJSON(data, rules) {
-  return JSON.parse(JSON.stringify(data), (key, value2) => {
+  return JSON.parse(JSON.stringify(data), (_key, value2) => {
     let result = value2;
     for (const rule of rules) {
       if (rule.test(result)) {
@@ -9720,7 +9781,7 @@ function transformJSON(data, rules) {
   });
 }
 
-// src/game-factory/expand-game-rules.js
+// src/game-factory/expand-game-rules.ts
 var invariantEntities = [
   {
     entityType: "Space",
@@ -9744,7 +9805,8 @@ function expandEntities(rules) {
 }
 function expandInitialPlacements(rules, entities) {
   if (rules.sharedBoard) {
-    const sharedBoardPlacements = rules.sharedBoard.map((matcher) => ({ entity: matcher, destination: { name: "sharedBoard" } }));
+    const sharedBoard = rules.sharedBoard;
+    const sharedBoardPlacements = sharedBoard.map((matcher) => ({ entity: matcher, destination: { name: "sharedBoard" } }));
     if (!rules.initialPlacements) rules.initialPlacements = [];
     rules.initialPlacements.unshift(...sharedBoardPlacements);
   }
@@ -9754,7 +9816,8 @@ function expandInitialPlacements(rules, entities) {
       name: "personalBoard",
       perPlayer: true
     });
-    const personalBoardPlacements = rules.personalBoard.map((matcher) => ({
+    const personalBoard = rules.personalBoard;
+    const personalBoardPlacements = personalBoard.map((matcher) => ({
       entity: matcher,
       destination: {
         name: "personalBoard"
@@ -9784,7 +9847,7 @@ function expandInitialPlacements(rules, entities) {
                 conditionType: "Is",
                 matcher: {
                   ...matcher,
-                  ...entityDefinition.perPlayer ? {
+                  ...entityDefinition?.perPlayer ? {
                     player: {
                       type: "contextPath",
                       path: ["loopTarget"]
@@ -9858,21 +9921,21 @@ var simpleReplacements = [
   ],
   [
     "ownerOfFirstResultEntity",
-    // might have to more tightly couple this to HasLine condition
     {
-      "type": "contextPath",
-      "path": ["results", 0, "matches", 0, 0, "entities", 0, "attributes", "player"]
+      type: "contextPath",
+      path: ["results", 0, "matches", 0, 0, "entities", 0, "attributes", "player"]
     }
   ]
 ];
 var transformationRules = [
   {
-    test: (val) => val && typeof val === "object",
+    test: (val) => Boolean(val && typeof val === "object"),
     replace: (val) => {
+      const obj = val;
       keyMappings.forEach(([oldKey, newKey]) => {
-        if (val.hasOwnProperty(oldKey)) {
-          val[newKey] = val[oldKey];
-          delete val[oldKey];
+        if (Object.prototype.hasOwnProperty.call(obj, oldKey)) {
+          obj[newKey] = obj[oldKey];
+          delete obj[oldKey];
         }
       });
       return val;
@@ -9890,22 +9953,24 @@ var transformationRules = [
     }
   },
   {
-    test: (val) => val?.conditions,
+    test: (val) => Boolean(val && typeof val === "object" && val.conditions),
     replace: (val) => {
-      if (!Array.isArray(val.conditions)) {
-        val.conditions = [val.conditions];
+      const v2 = val;
+      if (!Array.isArray(v2.conditions)) {
+        v2.conditions = [v2.conditions];
       }
       return val;
     }
   },
   {
-    test: (val) => val?.conditions,
+    test: (val) => Boolean(val && typeof val === "object" && val.conditions),
     replace: (val) => {
-      for (let i2 = 0, len = val.conditions.length; i2 < len; i2++) {
-        if (!val.conditions[i2].conditionType) {
-          val.conditions[i2] = {
+      const v2 = val;
+      for (let i2 = 0, len = v2.conditions.length; i2 < len; i2++) {
+        if (!v2.conditions[i2].conditionType) {
+          v2.conditions[i2] = {
             conditionType: "Is",
-            matcher: val.conditions[i2]
+            matcher: v2.conditions[i2]
           };
         }
       }
@@ -9913,18 +9978,21 @@ var transformationRules = [
     }
   },
   {
-    test: (val) => typeof val?.target === "string",
-    replace: (val) => ({
-      ...val,
-      target: {
-        conditions: [{
-          conditionType: "Is",
-          matcher: {
-            name: val.target
-          }
-        }]
-      }
-    })
+    test: (val) => Boolean(val && typeof val === "object" && typeof val.target === "string"),
+    replace: (val) => {
+      const v2 = val;
+      return {
+        ...v2,
+        target: {
+          conditions: [{
+            conditionType: "Is",
+            matcher: {
+              name: v2.target
+            }
+          }]
+        }
+      };
+    }
   }
 ];
 function expandGameRules(gameRules) {
@@ -9951,11 +10019,14 @@ function expandGameRules(gameRules) {
   return rules;
 }
 
-// src/utils/get-scenario-results.js
-function getScenarioResults(bgioArguments, scenarios, context) {
+// src/utils/get-scenario-results.ts
+function getScenarioResults(bgioArguments, scenarios) {
   let match;
   for (const scenario of scenarios) {
-    const conditionResults = checkConditions(bgioArguments, scenario);
+    const conditionResults = checkConditions(
+      bgioArguments,
+      scenario.conditions
+    );
     if (conditionResults.conditionsAreMet) {
       match = { scenario, conditionResults };
       break;
@@ -9972,7 +10043,7 @@ function getScenarioResults(bgioArguments, scenarios, context) {
   }
 }
 
-// src/game-factory/game-factory.js
+// src/game-factory/game-factory.ts
 function gameFactory(gameRules, gameName) {
   const game = { name: gameName };
   const rules = expandGameRules(gameRules);
@@ -9985,19 +10056,21 @@ function gameFactory(gameRules, gameName) {
       }
     };
     const entityDefinitions = expandEntityDefinitions(rules.entities, ctx);
-    initialState.bank = new bank_default(entityDefinitions);
-    initialState.sharedBoard = initialState.bank.getOne(
+    const bank = new bank_default(entityDefinitions);
+    initialState.bank = bank;
+    initialState.sharedBoard = bank.getOne(
       bgioArguments,
       {
         conditions: [{
           conditionType: "Is",
           matcher: { name: "sharedBoard" }
         }]
-      }
+      },
+      {}
     );
     if (rules.personalBoard) {
       initialState.personalBoards = bgioArguments.ctx.playOrder.map(
-        (playerID) => initialState.bank.getOne(
+        (playerID) => bank.getOne(
           bgioArguments,
           {
             conditions: [{
@@ -10007,13 +10080,16 @@ function gameFactory(gameRules, gameName) {
                 player: playerID
               }
             }]
-          }
+          },
+          {}
         )
       );
     }
     rules.initialMoves?.forEach((moveRule) => {
       moveFactory(moveRule, game).moveInstance.doMove(
-        { ...bgioArguments, G: initialState }
+        { ...bgioArguments, G: initialState },
+        void 0,
+        {}
       );
     });
     return JSON.parse(serialize(initialState));
@@ -10031,16 +10107,18 @@ function gameFactory(gameRules, gameName) {
     }), {});
   }
   if (rules.endIf) {
+    const endIfRules = rules.endIf;
     game.endIf = (bgioArguments) => {
       const newBgioArguments = deserializeBgioArguments(bgioArguments);
-      return getScenarioResults(newBgioArguments, rules.endIf);
+      return getScenarioResults(newBgioArguments, endIfRules);
     };
   }
   if (!gameRules.DEBUG_DISABLE_SECRET_STATE) {
     game.playerView = (bgioArguments) => {
       const { G: G2, playerID } = deserializeBgioArguments(bgioArguments);
-      Object.values(G2.bank.tracker).forEach((entity) => {
-        if (entity.rule.contentsHiddenFrom === "All" || entity.rule.contentsHiddenFrom === "Others" && (playerID !== entity.rule.player || playerID == void 0)) {
+      const tracker = G2.bank.tracker;
+      Object.values(tracker).forEach((entity) => {
+        if (entity.rule.contentsHiddenFrom === "All" || entity.rule.contentsHiddenFrom === "Others" && (playerID !== entity.rule.player || playerID === void 0)) {
           if (entity.spaces) {
             entity.spaces = entity.rule.hideLength ? [] : entity.spaces.map(() => G2.bank.createEntity());
           }
@@ -10060,12 +10138,12 @@ function expandEntityDefinitions(entities, ctx) {
     if (entityCopy.perPlayer) {
       delete entityCopy.perPlayer;
       if (entityCopy.variants) {
-        entityCopy.variants = new Array(ctx.numPlayers).fill().reduce((accu, _2, i2) => [
+        entityCopy.variants = new Array(ctx.numPlayers).fill(void 0).reduce((accu, _2, i2) => [
           ...accu,
           ...entityCopy.variants.map((variant) => ({ ...variant, player: `${i2}` }))
         ], []);
       } else {
-        entityCopy.variants = new Array(ctx.numPlayers).fill().map((_2, i2) => ({ player: `${i2}` }));
+        entityCopy.variants = new Array(ctx.numPlayers).fill(void 0).map((_2, i2) => ({ player: `${i2}` }));
       }
     }
     if (entityCopy.variants) {
@@ -10103,9 +10181,10 @@ function createTurn(turnRule, game) {
       }
     });
   }
-  if (turnRule.order?.playOrder === "RotateFirst") {
-    turnRule.order.first = () => 0;
-    turnRule.order.next = ({ ctx }) => (ctx.playOrderPos + 1) % ctx.numPlayers;
+  const order = turnRule.order;
+  if (order?.playOrder === "RotateFirst") {
+    order.first = () => 0;
+    order.next = ({ ctx }) => (ctx.playOrderPos + 1) % ctx.numPlayers;
     turn.order.playOrder = ({ ctx, G: G2 }) => {
       return G2._meta.isAfterFirstPhase ? [...ctx.playOrder.slice(1), ctx.playOrder[0]] : ctx.playOrder;
     };
@@ -10128,10 +10207,11 @@ function createPhase(phaseRule, game) {
     return JSON.parse(serialize(newBgioArguments.G));
   };
   if (phaseRule.endIf) {
+    const phaseEndIf = phaseRule.endIf;
     phase.endIf = (bgioArguments) => {
       const newBgioArguments = deserializeBgioArguments(bgioArguments);
       if (newBgioArguments.G._meta.currentPhaseHasBeenSetUp) {
-        const result = getScenarioResults(newBgioArguments, phaseRule.endIf);
+        const result = getScenarioResults(newBgioArguments, phaseEndIf);
         if (result) {
           return result;
         }
@@ -27015,21 +27095,24 @@ function SocketIO({ server, socketOpts } = {}) {
 var import_lodash4 = __toESM(require_lodash());
 var import_rfc69024 = __toESM(require_rfc6902());
 
-// src/utils/prepare-payload.js
+// src/utils/prepare-payload.ts
 function preparePayload(payload) {
-  if (payload?.arguments) {
-    const payloadCopy = { ...payload };
-    payloadCopy.arguments = Object.entries(payloadCopy.arguments).reduce((acc, [key, argument]) => ({
-      ...acc,
-      [key]: argument.abstract ? argument : argument.entityId
-    }), {});
+  const p2 = payload;
+  if (p2?.arguments) {
+    const payloadCopy = {
+      ...p2,
+      arguments: Object.entries(p2.arguments).reduce((acc, [key, argument]) => ({
+        ...acc,
+        [key]: argument.abstract ? argument : argument.entityId
+      }), {})
+    };
     return JSON.parse(serialize(payloadCopy, { deduplicateInstances: false }));
   } else {
     return payload;
   }
 }
 
-// src/utils/get-steps.js
+// src/utils/get-steps.ts
 var argNamesMap = {
   PlaceNew: ["destination"],
   RemoveEntity: ["entity"],
@@ -27038,13 +27121,15 @@ var argNamesMap = {
   SetState: ["entity", "state"]
 };
 function getSteps(bgioState, moveRule) {
-  return argNamesMap[moveRule.moveType].filter((argName) => moveRule.arguments[argName].playerChoice).map((argName) => ({
+  const names = argNamesMap[moveRule.moveType];
+  if (!names) return [];
+  return names.filter((argName) => moveRule.arguments[argName]?.playerChoice).map((argName) => ({
     argName,
     getClickable: argName === "state" ? () => moveRule.arguments[argName].possibleValues.map((value2) => ({
       abstract: true,
       ...moveRule.arguments[argName],
       value: value2
-    })) : (context) => bgioState.G.bank.findAll(
+    })) : (context) => bankOf(bgioState).findAll(
       bgioState,
       moveRule.arguments[argName],
       context
@@ -27052,12 +27137,11 @@ function getSteps(bgioState, moveRule) {
   }));
 }
 
-// src/utils/create-payload.js
-function createPayload(bgioState, moveRule, targets, context) {
+// src/utils/create-payload.ts
+function createPayload(bgioState, moveRule, targets, _context) {
   const argNames = getSteps(
     bgioState,
-    moveRule,
-    context
+    moveRule
   ).map((s2) => s2.argName);
   return {
     arguments: targets.reduce((acc, target, i2) => ({
@@ -27067,11 +27151,11 @@ function createPayload(bgioState, moveRule, targets, context) {
   };
 }
 
-// src/client/client.js
+// src/client/client.ts
 var Client2 = class {
   constructor(options) {
     this.options = options;
-    this.game = options.boardgameIOGame || gameFactory(JSON.parse(options.gameRules), options.gameName);
+    this.game = options.boardgameIOGame || gameFactory(JSON.parse(options.gameRules), options.gameName ?? "");
     if (!options.boardgameIOGame) {
       this.moveBuilder = { targets: [], stepIndex: 0, eliminatedMoves: [] };
       this.optimisticWinner = null;
@@ -27095,7 +27179,7 @@ var Client2 = class {
         game: this.game,
         multiplayer,
         matchID,
-        playerID,
+        playerID: playerID ?? void 0,
         credentials,
         numPlayers,
         debug
@@ -27105,8 +27189,9 @@ var Client2 = class {
       this.client.start();
       return this;
     } catch (error2) {
-      console.error("Failed to join game:", error2?.message ?? error2);
-      if (error2?.stack) console.error(error2.stack);
+      const err = error2;
+      console.error("Failed to join game:", err?.message ?? error2);
+      if (err?.stack) console.error(err.stack);
     }
   }
   update() {
@@ -27149,7 +27234,12 @@ var Client2 = class {
       return;
     }
     const remainingMoveEntries = Object.entries(_possibleMoveMeta).filter(([name]) => !newEliminated.includes(name));
-    if (isMoveCompleted(state, _wrappedMoves, remainingMoveEntries, this.moveBuilder.stepIndex)) {
+    if (isMoveCompleted(
+      state,
+      _wrappedMoves,
+      remainingMoveEntries,
+      this.moveBuilder.stepIndex
+    )) {
       const [moveName] = remainingMoveEntries[0];
       const move = _wrappedMoves[moveName];
       const payload = createPayload(
@@ -27197,7 +27287,10 @@ function getPossibleMoves(bgioState, moves, moveBuilder) {
   const _possibleMoveMeta = {};
   const allClickable = /* @__PURE__ */ new Set();
   Object.entries(moves).filter(([moveName]) => !eliminatedMoves.includes(moveName)).forEach(([moveName, move]) => {
-    const moveRule = resolveProperties(bgioState, { ...move.moveInstance.rule, moveName });
+    const moveRule = resolveProperties(bgioState, {
+      ...move.moveInstance.rule,
+      moveName
+    });
     const context = {
       moveInstance: move.moveInstance,
       moveArguments: moveRule.arguments
@@ -27205,10 +27298,23 @@ function getPossibleMoves(bgioState, moves, moveBuilder) {
     const targets = moveBuilder.targets.map(
       (t2) => t2.abstract ? t2 : bgioState.G.bank.locate(t2.entityId)
     );
-    const payload = createPayload(bgioState, moveRule, targets, context);
+    const payload = createPayload(
+      bgioState,
+      moveRule,
+      targets,
+      context
+    );
     context.moveArguments = { ...context.moveArguments, ...payload.arguments };
-    const moveIsAllowed = checkConditions(bgioState, moveRule, {}, context).conditionsAreMet;
-    const moveSteps = getSteps(bgioState, moveRule);
+    const moveIsAllowed = checkConditions(
+      bgioState,
+      moveRule.conditions,
+      {},
+      context
+    ).conditionsAreMet;
+    const moveSteps = getSteps(
+      bgioState,
+      moveRule
+    );
     const clickableForMove = new Set(
       moveIsAllowed && moveSteps?.[stepIndex]?.getClickable(context) || []
     );
@@ -27218,11 +27324,19 @@ function getPossibleMoves(bgioState, moves, moveBuilder) {
   return { _possibleMoveMeta, allClickable };
 }
 function isMoveCompleted(state, moves, remainingMoveEntries, stepIndex) {
-  return remainingMoveEntries.length === 1 && getSteps(state, moves[remainingMoveEntries[0][0]].moveInstance.rule).length === stepIndex + 1;
+  return remainingMoveEntries.length === 1 && getSteps(
+    state,
+    moves[remainingMoveEntries[0][0]].moveInstance.rule
+  ).length === stepIndex + 1;
 }
 function getWinnerAfterMove(state, game, moveInstance, movePayload) {
-  const simulatedG = simulateMove(state, preparePayload(movePayload), { moveInstance });
-  return game.endIf?.({ ...state, G: JSON.parse(serialize(simulatedG)) });
+  const simulatedG = simulateMove(
+    state,
+    preparePayload(movePayload),
+    { moveInstance }
+  );
+  const endIf = game.endIf;
+  return endIf?.({ ...state, G: JSON.parse(serialize(simulatedG)) });
 }
 /*! Bundled license information: