@bct-app/game-engine 0.1.17 → 0.1.19

package/dist/index.mjs

@@ -505,6 +505,521 @@ var effectHandlers = {
   STATUS_CHANGE: applyStatusChange
 };
 
+// src/dsl/context.ts
+var decoratePlayer = (player, characterMap, currentTurn) => {
+  const isDead = Boolean(player.isDead);
+  const retainsBypass = isDead && (player.retainsAbility === "ALIVENESS" || player.retainsAbility === "ALL");
+  const wasExecuted = isDead && player.deathCause === "EXECUTION";
+  return {
+    ...player,
+    characterKind: characterMap.get(player.characterId)?.kind,
+    reminderMarks: (player.reminders ?? []).map((r) => r.mark),
+    effectiveAlive: !isDead || retainsBypass,
+    diedThisTurn: isDead && typeof player.deathTurn === "number" && player.deathTurn === currentTurn,
+    wasExecuted,
+    wasExecutedToday: wasExecuted && player.deathTurn === currentTurn
+  };
+};
+var isExecutionTimeline = (tl) => {
+  if (!tl) return false;
+  return (tl.operations ?? []).some((op) => op.kind === "execution");
+};
+var buildDslContextFromDerived = (derived, payload = []) => {
+  const players = derived.players.map((p) => decoratePlayer(p, derived.characterMap, derived.currentTurn));
+  const effector = players.find((p) => p.seat === derived.effectorSeat);
+  const aliveCount = players.filter((p) => !p.isDead).length;
+  const deadCount = players.length - aliveCount;
+  const executedTodayCount = players.filter(
+    (p) => p.isDead && p.deathCause === "EXECUTION" && p.deathTurn === derived.currentTurn
+  ).length;
+  const nominatedTodayCount = derived.todayNominations.length;
+  const playerDiedToday = players.some(
+    (p) => p.isDead && typeof p.deathTurn === "number" && p.deathTurn === derived.currentTurn
+  );
+  return {
+    effector,
+    players,
+    operations: {
+      all: derived.allOperations,
+      today: derived.todayOperations,
+      tonight: derived.tonightOperations,
+      yesterdayDay: derived.yesterdayDayOperations,
+      yesterdayNight: derived.yesterdayNightOperations
+    },
+    nominations: {
+      all: derived.allNominations,
+      today: derived.todayNominations,
+      yesterday: derived.yesterdayNominations
+    },
+    currentTimeline: {
+      turn: derived.currentTurn,
+      phase: derived.currentPhase,
+      time: derived.currentPhase === "NIGHT" ? "night" : derived.currentPhase === "DAY" ? "day" : void 0,
+      isFirstOfPhase: derived.isFirstOfPhase,
+      isExecution: (derived.currentPhase === "DAY" ? derived.todayOperations : derived.tonightOperations).some((op) => op.kind === "execution")
+    },
+    global: {
+      aliveCount,
+      deadCount,
+      executedTodayCount,
+      nominatedTodayCount,
+      executionHappenedToday: derived.todayOperations.some((op) => op.kind === "execution"),
+      playerDiedToday
+    },
+    payload
+  };
+};
+var buildDslContextFromLifetime = ({
+  snapshotSeatMap,
+  timelines,
+  nowTimelineIndex,
+  characterMap,
+  effector,
+  payloads
+}) => {
+  const nowTl = timelines[nowTimelineIndex];
+  const currentTurn = nowTl?.turn ?? -1;
+  const currentTime = nowTl?.time;
+  const currentPhase = currentTime === "night" ? "NIGHT" : currentTime === "day" ? "DAY" : "NIGHT";
+  const playersRaw = snapshotSeatMap ? [...snapshotSeatMap.values()] : [];
+  const players = playersRaw.map((p) => decoratePlayer(p, characterMap, currentTurn));
+  const effectorDecorated = effector ? players.find((p) => p.seat === effector.seat) ?? decoratePlayer(effector, characterMap, currentTurn) : void 0;
+  const todayOps = timelines.filter((tl) => tl.turn === currentTurn && tl.time === "day").flatMap((tl) => tl.operations ?? []);
+  const tonightOps = timelines.filter((tl) => tl.turn === currentTurn && tl.time === "night").flatMap((tl) => tl.operations ?? []);
+  const yesterdayDayOps = timelines.filter((tl) => tl.turn === currentTurn - 1 && tl.time === "day").flatMap((tl) => tl.operations ?? []);
+  const yesterdayNightOps = timelines.filter((tl) => tl.turn === currentTurn - 1 && tl.time === "night").flatMap((tl) => tl.operations ?? []);
+  const allOps = timelines.flatMap((tl) => tl.operations ?? []);
+  const todayNoms = timelines.filter((tl) => tl.turn === currentTurn && tl.time === "day").flatMap((tl) => (tl.nominations ?? []).map((n) => ({ nominator: n.nominator, nominee: n.nominee })));
+  const yesterdayNoms = timelines.filter((tl) => tl.turn === currentTurn - 1 && tl.time === "day").flatMap((tl) => (tl.nominations ?? []).map((n) => ({ nominator: n.nominator, nominee: n.nominee })));
+  const allNoms = timelines.filter((tl) => tl.time === "day").flatMap((tl) => (tl.nominations ?? []).map((n) => ({
+    nominator: n.nominator,
+    nominee: n.nominee,
+    turn: tl.turn
+  })));
+  const aliveCount = players.filter((p) => !p.isDead).length;
+  const deadCount = players.length - aliveCount;
+  const executedTodayCount = players.filter(
+    (p) => p.isDead && p.deathCause === "EXECUTION" && p.deathTurn === currentTurn
+  ).length;
+  const playerDiedToday = timelines.some((tl) => {
+    if (tl.turn !== currentTurn || tl.time !== "day") return false;
+    return (tl.operations ?? []).some((op) => {
+      const kind = op.kind;
+      return kind === "execution" || kind === "death";
+    });
+  });
+  return {
+    effector: effectorDecorated,
+    players,
+    operations: {
+      all: allOps,
+      today: todayOps,
+      tonight: tonightOps,
+      yesterdayDay: yesterdayDayOps,
+      yesterdayNight: yesterdayNightOps
+    },
+    nominations: {
+      all: allNoms,
+      today: todayNoms,
+      yesterday: yesterdayNoms
+    },
+    currentTimeline: {
+      turn: currentTurn,
+      phase: currentPhase,
+      time: currentTime,
+      isFirstOfPhase: false,
+      isExecution: isExecutionTimeline(nowTl)
+    },
+    global: {
+      aliveCount,
+      deadCount,
+      executedTodayCount,
+      nominatedTodayCount: todayNoms.length,
+      executionHappenedToday: timelines.some(
+        (tl) => tl.turn === currentTurn && tl.time === "day" && isExecutionTimeline(tl)
+      ),
+      playerDiedToday
+    },
+    payload: payloads
+  };
+};
+
+// src/dsl/bindings.ts
+var rootBindings = (ctx) => ({
+  effector: ctx.effector,
+  players: ctx.players,
+  operations: ctx.operations,
+  nominations: ctx.nominations,
+  currentTimeline: ctx.currentTimeline,
+  global: ctx.global,
+  payload: ctx.payload
+});
+var extendBindings = (parent, name, value) => ({
+  ...parent,
+  [name]: value
+});
+
+// src/dsl/operators.ts
+var deepEqual = (a, b) => {
+  if (a === b) return true;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!deepEqual(a[i], b[i])) return false;
+    }
+    return true;
+  }
+  return false;
+};
+var asNumber = (v) => typeof v === "number" && Number.isFinite(v) ? v : void 0;
+var compareOrder = (lhs, rhs, cmp) => {
+  const l = asNumber(lhs);
+  const r = asNumber(rhs);
+  if (l === void 0 || r === void 0) return false;
+  return cmp(l, r);
+};
+var applyOperator = (op, lhs, rhs) => {
+  switch (op) {
+    case "EQ":
+      return deepEqual(lhs, rhs);
+    case "NE":
+      return !deepEqual(lhs, rhs);
+    case "LT":
+      return compareOrder(lhs, rhs, (l, r) => l < r);
+    case "LTE":
+      return compareOrder(lhs, rhs, (l, r) => l <= r);
+    case "GT":
+      return compareOrder(lhs, rhs, (l, r) => l > r);
+    case "GTE":
+      return compareOrder(lhs, rhs, (l, r) => l >= r);
+    case "IN":
+      return Array.isArray(rhs) && rhs.some((v) => deepEqual(v, lhs));
+    case "NOT_IN":
+      return Array.isArray(rhs) && !rhs.some((v) => deepEqual(v, lhs));
+    case "CONTAINS":
+      if (Array.isArray(lhs)) return lhs.some((v) => deepEqual(v, rhs));
+      if (typeof lhs === "string") return typeof rhs === "string" && lhs.includes(rhs);
+      return false;
+    case "MATCHES":
+      if (typeof lhs !== "string" || typeof rhs !== "string") return false;
+      try {
+        return new RegExp(rhs).test(lhs);
+      } catch {
+        return false;
+      }
+    case "EXISTS":
+      return lhs !== void 0 && lhs !== null;
+    case "TRUTHY":
+      return Boolean(lhs);
+  }
+};
+var applyCountOperator = (op, actual, expected) => {
+  switch (op) {
+    case "EQ":
+      return actual === expected;
+    case "NE":
+      return actual !== expected;
+    case "LT":
+      return actual < expected;
+    case "LTE":
+      return actual <= expected;
+    case "GT":
+      return actual > expected;
+    case "GTE":
+      return actual >= expected;
+  }
+};
+
+// src/dsl/path.ts
+var MAX_STEPS = 32;
+var stepInto = (current, step) => {
+  if (current === void 0 || current === null) return void 0;
+  if (step.kind === "field") {
+    if (typeof current !== "object") return void 0;
+    const record = current;
+    return record[step.name];
+  }
+  if (step.kind === "index") {
+    if (!Array.isArray(current)) return void 0;
+    return current[step.value];
+  }
+  return void 0;
+};
+var evaluatePath = (path, bindings) => {
+  if (path.steps.length > MAX_STEPS) return void 0;
+  let current = Object.prototype.hasOwnProperty.call(bindings, path.root) ? bindings[path.root] : void 0;
+  for (const step of path.steps) {
+    current = stepInto(current, step);
+    if (current === void 0) return void 0;
+  }
+  return current;
+};
+
+// src/dsl/eval.ts
+var MAX_EXPR_DEPTH = 16;
+var MAX_QUANTIFIER_SIZE = 256;
+var resolveValue = (value, bindings) => {
+  if (!value) return void 0;
+  if (value.kind === "LITERAL") return value.value;
+  return evaluatePath(value.path, bindings);
+};
+var evalAtom = (atom, bindings, depth) => {
+  if (atom.type === "PATH") {
+    const lhs = evaluatePath(atom.path, bindings);
+    const rhs = resolveValue(atom.value, bindings);
+    return applyOperator(atom.op, lhs, rhs);
+  }
+  const source = evaluatePath(atom.source, bindings);
+  if (!Array.isArray(source)) {
+    return atom.type === "FORALL";
+  }
+  if (source.length > MAX_QUANTIFIER_SIZE) return false;
+  if (atom.type === "EXISTS") {
+    return source.some(
+      (item) => evalExpr(atom.where, extendBindings(bindings, atom.as, item), depth + 1)
+    );
+  }
+  if (atom.type === "FORALL") {
+    return source.every(
+      (item) => evalExpr(atom.where, extendBindings(bindings, atom.as, item), depth + 1)
+    );
+  }
+  let count = 0;
+  for (const item of source) {
+    if (!atom.where || evalExpr(atom.where, extendBindings(bindings, atom.as, item), depth + 1)) {
+      count += 1;
+    }
+  }
+  return applyCountOperator(atom.op, count, atom.value);
+};
+var evalExpr = (expr, bindings, depth = 0) => {
+  if (depth > MAX_EXPR_DEPTH) return false;
+  switch (expr.op) {
+    case "AND":
+      return expr.children.every((child) => evalExpr(child, bindings, depth + 1));
+    case "OR":
+      return expr.children.some((child) => evalExpr(child, bindings, depth + 1));
+    case "NOT":
+      return !evalExpr(expr.child, bindings, depth + 1);
+    case "ATOM":
+      return evalAtom(expr.atom, bindings, depth + 1);
+  }
+};
+var evalDslExpr = (expr, ctx) => evalExpr(expr, rootBindings(ctx), 0);
+
+// src/dsl/catalog.ts
+var PLAYER_FIELDS = [
+  { name: "seat", type: "number", label: "\u5EA7\u4F4D\u53F7" },
+  { name: "alignment", type: "string", label: "\u9635\u8425", description: "GOOD / EVIL" },
+  { name: "isDead", type: "boolean", label: "\u662F\u5426\u6B7B\u4EA1" },
+  { name: "effectiveAlive", type: "boolean", label: "\u6709\u6548\u5B58\u6D3B", description: "\u8003\u8651 retainsAbility\uFF08ALIVENESS/ALL\uFF09\u540E\u662F\u5426\u6309\u5B58\u6D3B\u5904\u7406" },
+  { name: "diedThisTurn", type: "boolean", label: "\u672C\u56DE\u5408\u6B7B\u4EA1" },
+  { name: "wasExecuted", type: "boolean", label: "\u66FE\u88AB\u5904\u51B3" },
+  { name: "wasExecutedToday", type: "boolean", label: "\u4ECA\u65E5\u88AB\u5904\u51B3" },
+  { name: "characterId", type: "string", label: "\u89D2\u8272 ID" },
+  { name: "characterKind", type: "string", label: "\u89D2\u8272\u7C7B\u578B", description: "Townsfolk / Outsiders / Minions / Demons" },
+  { name: "deathCause", type: "string", label: "\u6B7B\u4EA1\u539F\u56E0", description: "EXECUTION / DEMON / ABILITY / STORYTELLER / OTHER" },
+  { name: "deathTurn", type: "number", label: "\u6B7B\u4EA1\u56DE\u5408" },
+  { name: "abilities", type: "string[]", label: "\u80FD\u529B ID \u5217\u8868" },
+  { name: "reminderMarks", type: "string[]", label: "\u63D0\u793A\u7269 mark \u5217\u8868" },
+  { name: "hasUsedDeadVote", type: "boolean", label: "\u662F\u5426\u4F7F\u7528\u8FC7\u6B7B\u4EA1\u6295\u7968" },
+  { name: "retainsAbility", type: "string", label: "\u80FD\u529B\u4FDD\u7559\u8303\u56F4" }
+];
+var OPERATION_FIELDS = [
+  { name: "effector", type: "number", label: "\u65BD\u52A8\u8005\u5EA7\u4F4D" },
+  { name: "abilityId", type: "string", label: "\u80FD\u529B ID" },
+  { name: "kind", type: "string", label: "\u64CD\u4F5C\u79CD\u7C7B" },
+  { name: "payloads", type: "unknown[]", label: "Payload \u5217\u8868" }
+];
+var NOMINATION_FIELDS = [
+  { name: "nominator", type: "number", label: "\u63D0\u540D\u8005\u5EA7\u4F4D" },
+  { name: "nominee", type: "number", label: "\u88AB\u63D0\u540D\u8005\u5EA7\u4F4D" },
+  { name: "turn", type: "number", label: "\u56DE\u5408", description: "\u4EC5 all \u96C6\u5408\u53EF\u7528" }
+];
+var CURRENT_TIMELINE_FIELDS = [
+  { name: "turn", type: "number", label: "\u5F53\u524D\u56DE\u5408" },
+  { name: "phase", type: "string", label: "\u5F53\u524D\u9636\u6BB5", description: "NIGHT / DAY / DUSK / DAWN" },
+  { name: "time", type: "string", label: "\u5F53\u524D\u65F6\u6BB5", description: "night / day" },
+  { name: "isFirstOfPhase", type: "boolean", label: "\u662F\u5426\u672C\u9636\u6BB5\u9996\u6B21" },
+  { name: "isExecution", type: "boolean", label: "\u5F53\u524D\u65F6\u95F4\u7EBF\u542B\u5904\u51B3" }
+];
+var GLOBAL_FIELDS = [
+  { name: "aliveCount", type: "number", label: "\u5B58\u6D3B\u73A9\u5BB6\u6570" },
+  { name: "deadCount", type: "number", label: "\u6B7B\u4EA1\u73A9\u5BB6\u6570" },
+  { name: "executedTodayCount", type: "number", label: "\u4ECA\u65E5\u88AB\u5904\u51B3\u4EBA\u6570" },
+  { name: "nominatedTodayCount", type: "number", label: "\u4ECA\u65E5\u63D0\u540D\u603B\u6570" },
+  { name: "executionHappenedToday", type: "boolean", label: "\u4ECA\u65E5\u662F\u5426\u5DF2\u53D1\u751F\u5904\u51B3" },
+  { name: "playerDiedToday", type: "boolean", label: "\u4ECA\u65E5\u662F\u5426\u6709\u73A9\u5BB6\u6B7B\u4EA1" }
+];
+var OPERATIONS_FIELDS = [
+  { name: "all", type: "operation[]", label: "\u6240\u6709\u64CD\u4F5C" },
+  { name: "today", type: "operation[]", label: "\u4ECA\u65E5\u64CD\u4F5C" },
+  { name: "tonight", type: "operation[]", label: "\u4ECA\u591C\u64CD\u4F5C" },
+  { name: "yesterdayDay", type: "operation[]", label: "\u6628\u65E5\u767D\u5929\u64CD\u4F5C" },
+  { name: "yesterdayNight", type: "operation[]", label: "\u6628\u591C\u64CD\u4F5C" }
+];
+var NOMINATIONS_FIELDS = [
+  { name: "all", type: "nomination[]", label: "\u6240\u6709\u63D0\u540D" },
+  { name: "today", type: "nomination[]", label: "\u4ECA\u65E5\u63D0\u540D" },
+  { name: "yesterday", type: "nomination[]", label: "\u6628\u65E5\u63D0\u540D" }
+];
+var DSL_CATALOG = [
+  {
+    name: "effector",
+    type: "player",
+    label: "\u80FD\u529B\u53D1\u52A8\u8005",
+    description: "\u5F53\u524D\u8BC4\u4F30\u65F6\u7684\u80FD\u529B\u65BD\u653E\u8005\u5FEB\u7167",
+    fields: PLAYER_FIELDS
+  },
+  {
+    name: "players",
+    type: "player[]",
+    label: "\u5168\u90E8\u73A9\u5BB6",
+    description: "\u5F53\u524D\u5FEB\u7167\u4E0B\u6240\u6709\u73A9\u5BB6\uFF08\u5E94\u914D\u5408 EXISTS / FORALL / COUNT \u4F7F\u7528\uFF09"
+  },
+  {
+    name: "operations",
+    type: "object",
+    label: "\u5386\u53F2\u64CD\u4F5C\u96C6\u5408",
+    fields: OPERATIONS_FIELDS
+  },
+  {
+    name: "nominations",
+    type: "object",
+    label: "\u5386\u53F2\u63D0\u540D\u96C6\u5408",
+    fields: NOMINATIONS_FIELDS
+  },
+  {
+    name: "currentTimeline",
+    type: "object",
+    label: "\u5F53\u524D\u65F6\u95F4\u7EBF",
+    fields: CURRENT_TIMELINE_FIELDS
+  },
+  {
+    name: "global",
+    type: "object",
+    label: "\u5168\u5C40\u805A\u5408",
+    fields: GLOBAL_FIELDS
+  },
+  {
+    name: "payload",
+    type: "unknown[]",
+    label: "\u80FD\u529B Payload \u6570\u7EC4",
+    description: "\u5F53\u524D\u8C03\u7528 / \u64CD\u4F5C\u7684 payload \u539F\u59CB\u6570\u7EC4"
+  }
+];
+var DSL_ITEM_FIELDS = {
+  player: PLAYER_FIELDS,
+  operation: OPERATION_FIELDS,
+  nomination: NOMINATION_FIELDS
+};
+var DSL_OPERATORS = [
+  { value: "EQ", label: "\u7B49\u4E8E", arity: "binary" },
+  { value: "NE", label: "\u4E0D\u7B49\u4E8E", arity: "binary" },
+  { value: "LT", label: "<", arity: "binary" },
+  { value: "LTE", label: "<=", arity: "binary" },
+  { value: "GT", label: ">", arity: "binary" },
+  { value: "GTE", label: ">=", arity: "binary" },
+  { value: "IN", label: "\u5C5E\u4E8E", arity: "binary" },
+  { value: "NOT_IN", label: "\u4E0D\u5C5E\u4E8E", arity: "binary" },
+  { value: "CONTAINS", label: "\u5305\u542B", arity: "binary" },
+  { value: "MATCHES", label: "\u6B63\u5219\u5339\u914D", arity: "binary" },
+  { value: "EXISTS", label: "\u5B58\u5728", arity: "unary" },
+  { value: "TRUTHY", label: "\u4E3A\u771F", arity: "unary" }
+];
+
+// src/dsl/trace.ts
+var MAX_QUANTIFIER_SIZE2 = 256;
+var renderPath = (p) => p.steps.reduce((acc, s) => acc + (s.kind === "field" ? `.${s.name}` : `[${s.value}]`), p.root);
+var resolveValue2 = (value, bindings) => {
+  if (!value) return void 0;
+  if (value.kind === "LITERAL") return value.value;
+  return evaluatePath(value.path, bindings);
+};
+var renderValue = (value, bindings) => {
+  if (!value) return void 0;
+  if (value.kind === "LITERAL") return value.value;
+  return { ref: renderPath(value.path), resolved: evaluatePath(value.path, bindings) };
+};
+var traceAtom = (atom, bindings) => {
+  if (atom.type === "PATH") {
+    const lhs = evaluatePath(atom.path, bindings);
+    const rhs = resolveValue2(atom.value, bindings);
+    const ok2 = applyOperator(atom.op, lhs, rhs);
+    return {
+      op: "ATOM",
+      atomType: "PATH",
+      ok: ok2,
+      path: renderPath(atom.path),
+      operator: atom.op,
+      lhs,
+      rhs: renderValue(atom.value, bindings)
+    };
+  }
+  const source = evaluatePath(atom.source, bindings);
+  const sourceArr = Array.isArray(source) ? source : [];
+  const sizeCapped = sourceArr.length > MAX_QUANTIFIER_SIZE2;
+  let matched = 0;
+  if (!sizeCapped) {
+    for (const item of sourceArr) {
+      const childBindings = extendBindings(bindings, atom.as, item);
+      if (!atom.where || traceExprOk(atom.where, childBindings)) matched += 1;
+    }
+  }
+  if (atom.type === "COUNT") {
+    const ok2 = !sizeCapped && applyCountOperator(atom.op, matched, atom.value);
+    return {
+      op: "ATOM",
+      atomType: "COUNT",
+      ok: ok2,
+      source: renderPath(atom.source),
+      size: sourceArr.length,
+      matched,
+      operator: atom.op,
+      expected: atom.value,
+      bindings: atom.as
+    };
+  }
+  const ok = atom.type === "EXISTS" ? matched > 0 : !sizeCapped && (sourceArr.length === 0 || matched === sourceArr.length);
+  return {
+    op: "ATOM",
+    atomType: atom.type,
+    ok,
+    source: renderPath(atom.source),
+    size: sourceArr.length,
+    matched,
+    bindings: atom.as
+  };
+};
+var traceExprOk = (expr, bindings) => {
+  switch (expr.op) {
+    case "AND":
+      return expr.children.every((c) => traceExprOk(c, bindings));
+    case "OR":
+      return expr.children.some((c) => traceExprOk(c, bindings));
+    case "NOT":
+      return !traceExprOk(expr.child, bindings);
+    case "ATOM":
+      return traceAtom(expr.atom, bindings).ok;
+  }
+};
+var traceExpr = (expr, bindings) => {
+  if (expr.op === "AND") {
+    const children = expr.children.map((c) => traceExpr(c, bindings));
+    return { op: "AND", ok: children.every((c) => c.ok), children };
+  }
+  if (expr.op === "OR") {
+    const children = expr.children.map((c) => traceExpr(c, bindings));
+    return { op: "OR", ok: children.some((c) => c.ok), children };
+  }
+  if (expr.op === "NOT") {
+    const child = traceExpr(expr.child, bindings);
+    return { op: "NOT", ok: !child.ok, child };
+  }
+  return traceAtom(expr.atom, bindings);
+};
+var traceDslExpr = (expr, ctx) => traceExpr(expr, rootBindings(ctx));
+
 // src/effects/resolve-targets.ts
 var isPayloadRef = (value) => {
   if (!value || typeof value !== "object") {
@@ -532,11 +1047,6 @@ var resolveDynamicValue = (value, payloads, isExpected) => {
 var getSortedPlayers = (playerSeatMap) => {
   return [...playerSeatMap.values()].sort((left, right) => left.seat - right.seat);
 };
-var getCircularDistance = (anchorIdx, targetIdx, total) => {
-  const clockwise = (targetIdx - anchorIdx + total) % total;
-  const anticlockwise = (anchorIdx - targetIdx + total) % total;
-  return Math.min(clockwise, anticlockwise);
-};
 var getAnchorSeat = (dynamicTarget, payloads, effector) => {
   const anchor = dynamicTarget.anchor;
   if (!anchor || anchor.from === "EFFECTOR") {
@@ -555,43 +1065,23 @@ var resolveSelectorScope = (dynamicTarget, payloads) => {
     (value) => value === "BOTH_SIDES" || value === "LEFT_SIDE" || value === "RIGHT_SIDE"
   ) ?? "BOTH_SIDES";
 };
-var getCandidatesBySelector = (dynamicTarget, sortedPlayers, anchorSeat, payloads) => {
-  const selector = dynamicTarget.selector;
-  if (!selector) {
-    return sortedPlayers;
-  }
-  const scope = resolveSelectorScope(dynamicTarget, payloads);
-  if (!anchorSeat) {
-    return [];
-  }
-  const anchorIdx = sortedPlayers.findIndex((player) => player.seat === anchorSeat);
-  if (anchorIdx < 0) {
-    return [];
-  }
-  const total = sortedPlayers.length;
-  if (scope === "LEFT_SIDE") {
-    const left2 = [];
-    for (let step = 1; step < total; step += 1) {
-      left2.push(sortedPlayers[(anchorIdx + step) % total]);
-    }
-    return left2;
-  }
-  if (scope === "RIGHT_SIDE") {
-    const right2 = [];
-    for (let step = 1; step < total; step += 1) {
-      right2.push(sortedPlayers[(anchorIdx - step + total) % total]);
-    }
-    return right2;
-  }
-  const left = [];
-  const right = [];
-  for (let step = 1; step < total; step += 1) {
-    left.push(sortedPlayers[(anchorIdx + step) % total]);
-    right.push(sortedPlayers[(anchorIdx - step + total) % total]);
-  }
-  return [...left, ...right];
+var matchesExprCondition = (player, condition, playerSeatMap, characterMap, effector, payloads) => {
+  const dslCtx = buildDslContextFromLifetime({
+    snapshotSeatMap: playerSeatMap,
+    timelines: [],
+    nowTimelineIndex: -1,
+    characterMap,
+    effector,
+    payloads
+  });
+  const decoratedPlayer = dslCtx.players.find((p) => p.seat === player.seat);
+  const bindings = extendBindings(rootBindings(dslCtx), "it", decoratedPlayer ?? player);
+  return evalExpr(condition.expr, bindings);
 };
-var matchesCondition = (player, condition, payloads, characterMap) => {
+var matchesCondition = (player, condition, payloads, characterMap, playerSeatMap, effector) => {
+  if (condition.kind === "EXPR") {
+    return matchesExprCondition(player, condition, playerSeatMap, characterMap, effector, payloads);
+  }
   if (condition.field === "IS_DEAD") {
     const expected = resolveDynamicValue(condition.value, payloads, (value) => typeof value === "boolean");
     if (typeof expected !== "boolean") {
@@ -607,6 +1097,18 @@ var matchesCondition = (player, condition, payloads, characterMap) => {
     const expectedSeat = resolveDynamicValue(condition.value, payloads, (value) => typeof value === "number");
     return typeof expectedSeat === "number" && player.seat === expectedSeat;
   }
+  if (condition.field === "ALIGNMENT") {
+    const alignment = player.alignment;
+    if (!alignment) {
+      return false;
+    }
+    if (condition.operator === "IN") {
+      const expectedAlignments = resolveDynamicValue(condition.value, payloads, (value) => Array.isArray(value) && value.every((item) => typeof item === "string"));
+      return Array.isArray(expectedAlignments) && expectedAlignments.includes(alignment);
+    }
+    const expectedAlignment = resolveDynamicValue(condition.value, payloads, (value) => typeof value === "string");
+    return typeof expectedAlignment === "string" && alignment === expectedAlignment;
+  }
   const character = characterMap.get(player.characterId);
   const kind = character?.kind;
   if (!kind) {
@@ -619,55 +1121,74 @@ var matchesCondition = (player, condition, payloads, characterMap) => {
   const expectedKind = resolveDynamicValue(condition.value, payloads, (value) => typeof value === "string");
   return typeof expectedKind === "string" && kind === expectedKind;
 };
-var filterByWhere = (candidates, dynamicTarget, payloads, characterMap) => {
+var passesWhere = (player, dynamicTarget, payloads, characterMap, playerSeatMap, effector) => {
   const where = dynamicTarget.where;
   const conditions = where?.conditions ?? [];
-  if (conditions.length === 0) {
-    return candidates;
-  }
+  if (conditions.length === 0) return true;
   const isAllMode = where?.mode !== "ANY";
-  return candidates.filter((player) => {
-    const results = conditions.map((condition) => matchesCondition(player, condition, payloads, characterMap));
-    return isAllMode ? results.every(Boolean) : results.some(Boolean);
-  });
+  const results = conditions.map(
+    (condition) => matchesCondition(player, condition, payloads, characterMap, playerSeatMap, effector)
+  );
+  return isAllMode ? results.every(Boolean) : results.some(Boolean);
 };
-var applySort = (candidates, dynamicTarget, payloads, sortedPlayers, anchorSeat) => {
+var walkSidesWithFilter = (dynamicTarget, sortedPlayers, anchorSeat, payloads, characterMap, playerSeatMap, effector) => {
   const scope = resolveSelectorScope(dynamicTarget, payloads);
-  if (scope !== "BOTH_SIDES") {
-    return [...candidates];
-  }
-  if (!anchorSeat || sortedPlayers.length <= 1) {
-    return [...candidates].sort((left, right) => left.seat - right.seat);
-  }
-  const seatIndexMap = new Map(sortedPlayers.map((player, idx) => [player.seat, idx]));
-  const anchorIdx = seatIndexMap.get(anchorSeat);
-  if (typeof anchorIdx !== "number") {
-    return [...candidates].sort((left, right) => left.seat - right.seat);
-  }
-  return [...candidates].sort((left, right) => {
-    const leftIdx = seatIndexMap.get(left.seat);
-    const rightIdx = seatIndexMap.get(right.seat);
-    if (typeof leftIdx !== "number" || typeof rightIdx !== "number") {
-      return left.seat - right.seat;
+  if (!anchorSeat) return { left: [], right: [] };
+  const anchorIdx = sortedPlayers.findIndex((player) => player.seat === anchorSeat);
+  if (anchorIdx < 0) return { left: [], right: [] };
+  const total = sortedPlayers.length;
+  const left = [];
+  const right = [];
+  if (scope === "LEFT_SIDE" || scope === "BOTH_SIDES") {
+    for (let step = 1; step < total; step += 1) {
+      const player = sortedPlayers[(anchorIdx + step) % total];
+      if (passesWhere(player, dynamicTarget, payloads, characterMap, playerSeatMap, effector)) left.push(player);
     }
-    const leftDistance = getCircularDistance(anchorIdx, leftIdx, sortedPlayers.length);
-    const rightDistance = getCircularDistance(anchorIdx, rightIdx, sortedPlayers.length);
-    if (leftDistance !== rightDistance) {
-      return leftDistance - rightDistance;
+  }
+  if (scope === "RIGHT_SIDE" || scope === "BOTH_SIDES") {
+    for (let step = 1; step < total; step += 1) {
+      const player = sortedPlayers[(anchorIdx - step + total) % total];
+      if (passesWhere(player, dynamicTarget, payloads, characterMap, playerSeatMap, effector)) right.push(player);
     }
-    return left.seat - right.seat;
-  });
+  }
+  return { left, right };
 };
-var pickTargets = (sortedCandidates, dynamicTarget, payloads) => {
-  const dedupedCandidates = [...new Map(sortedCandidates.map((player) => [player.seat, player])).values()];
+var pickBalanced = (sides, dynamicTarget, payloads) => {
   const configuredLimit = resolveDynamicValue(dynamicTarget.limit, payloads, (value) => typeof value === "number");
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  const pushUnique = (player) => {
+    if (!player || seen.has(player.seat)) return false;
+    seen.add(player.seat);
+    out.push(player);
+    return true;
+  };
   if (typeof configuredLimit === "undefined") {
-    return dedupedCandidates;
-  }
-  if (configuredLimit <= 0) {
-    return [];
+    sides.left.forEach(pushUnique);
+    sides.right.forEach(pushUnique);
+    return out;
+  }
+  if (configuredLimit <= 0) return [];
+  let li = 0;
+  let ri = 0;
+  let preferLeft = true;
+  while (out.length < configuredLimit && (li < sides.left.length || ri < sides.right.length)) {
+    if (preferLeft && li < sides.left.length) {
+      if (pushUnique(sides.left[li])) li += 1;
+      else li += 1;
+    } else if (!preferLeft && ri < sides.right.length) {
+      if (pushUnique(sides.right[ri])) ri += 1;
+      else ri += 1;
+    } else if (li < sides.left.length) {
+      if (pushUnique(sides.left[li])) li += 1;
+      else li += 1;
+    } else if (ri < sides.right.length) {
+      if (pushUnique(sides.right[ri])) ri += 1;
+      else ri += 1;
+    }
+    preferLeft = !preferLeft;
   }
-  return dedupedCandidates.slice(0, configuredLimit);
+  return out;
 };
 var resolveEffectTargets = ({
   effect,
@@ -700,10 +1221,14 @@ var resolveEffectTargets = ({
     const dynamicTarget = effect.target;
     const sortedPlayers = getSortedPlayers(playerSeatMap);
     const anchorSeat = getAnchorSeat(dynamicTarget, payloads, effector);
-    const candidates = getCandidatesBySelector(dynamicTarget, sortedPlayers, anchorSeat, payloads);
-    const filtered = filterByWhere(candidates, dynamicTarget, payloads, characterMap);
-    const ordered = applySort(filtered, dynamicTarget, payloads, sortedPlayers, anchorSeat);
-    return pickTargets(ordered, dynamicTarget, payloads);
+    if (!dynamicTarget.selector) {
+      const matches = sortedPlayers.filter(
+        (player) => passesWhere(player, dynamicTarget, payloads, characterMap, playerSeatMap, effector)
+      );
+      return pickBalanced({ left: matches, right: [] }, dynamicTarget, payloads);
+    }
+    const sides = walkSidesWithFilter(dynamicTarget, sortedPlayers, anchorSeat, payloads, characterMap, playerSeatMap, effector);
+    return pickBalanced(sides, dynamicTarget, payloads);
   }
   return [];
 };
@@ -848,7 +1373,7 @@ var evalPlayerState = (atom, ctx) => {
   const single = players[0];
   return evalPlayerStateOnPlayer(single, atom, ctx);
 };
-var isExecutionTimeline = (tl) => {
+var isExecutionTimeline2 = (tl) => {
   if (!tl) return false;
   return (tl.operations ?? []).some((op) => op.kind === "execution");
 };
@@ -876,7 +1401,7 @@ var evalTime = (atom, ctx) => {
       if (spec.event === "NEXT_NIGHT" && tl.time === "night") return false;
       if (spec.event === "NEXT_DUSK" && prevTime === "day" && tl.time === "night") return false;
       if (spec.event === "NEXT_DAWN" && prevTime === "night" && tl.time === "day") return false;
-      if (spec.event === "NEXT_EXECUTION" && isExecutionTimeline(tl)) return false;
+      if (spec.event === "NEXT_EXECUTION" && isExecutionTimeline2(tl)) return false;
       prevTime = tl.time;
     }
     return true;
@@ -917,7 +1442,7 @@ var evalGameState = (atom, ctx) => {
   if (spec.kind === "EXECUTION_HAPPENED_TODAY") {
     const turn = ctx.timelines[ctx.nowTimelineIndex]?.turn;
     if (typeof turn !== "number") return false;
-    return ctx.timelines.some((tl) => tl.turn === turn && tl.time === "day" && isExecutionTimeline(tl));
+    return ctx.timelines.some((tl) => tl.turn === turn && tl.time === "day" && isExecutionTimeline2(tl));
   }
   if (spec.kind === "PLAYER_DIED_TODAY") {
     const turn = ctx.timelines[ctx.nowTimelineIndex]?.turn;
@@ -932,7 +1457,7 @@ var evalGameState = (atom, ctx) => {
   }
   return true;
 };
-var evalAtom = (atom, ctx) => {
+var evalAtom2 = (atom, ctx) => {
   switch (atom.type) {
     case "TIME":
       return evalTime(atom, ctx);
@@ -951,18 +1476,30 @@ var evalAtom = (atom, ctx) => {
         target: ctx.target,
         snapshotSeatMap: ctx.snapshotSeatMap
       }) : false;
+    case "DSL": {
+      if (!ctx.snapshotSeatMap) return true;
+      const dslCtx = buildDslContextFromLifetime({
+        snapshotSeatMap: ctx.snapshotSeatMap,
+        timelines: ctx.timelines,
+        nowTimelineIndex: ctx.nowTimelineIndex,
+        characterMap: ctx.characterMap,
+        effector: ctx.effector,
+        payloads: ctx.payloads
+      });
+      return evalDslExpr(atom.expr, dslCtx);
+    }
   }
 };
-var evalExpr = (expr, ctx) => {
+var evalExpr2 = (expr, ctx) => {
   switch (expr.op) {
     case "AND":
-      return expr.children.every((child) => evalExpr(child, ctx));
+      return expr.children.every((child) => evalExpr2(child, ctx));
     case "OR":
-      return expr.children.some((child) => evalExpr(child, ctx));
+      return expr.children.some((child) => evalExpr2(child, ctx));
     case "NOT":
-      return !evalExpr(expr.child, ctx);
+      return !evalExpr2(expr.child, ctx);
     case "ATOM":
-      return evalAtom(expr.atom, ctx);
+      return evalAtom2(expr.atom, ctx);
   }
 };
 var expressionReferencesTarget = (expr) => {
@@ -1000,9 +1537,9 @@ var evaluateLifetime = ({
   const expr = lifetime.expr;
   const dependsOnTarget = expressionReferencesTarget(expr);
   if (!dependsOnTarget) {
-    return evalExpr(expr, { ...baseCtx, target: void 0 }) ? targets : [];
+    return evalExpr2(expr, { ...baseCtx, target: void 0 }) ? targets : [];
   }
-  return targets.filter((target) => evalExpr(expr, { ...baseCtx, target }));
+  return targets.filter((target) => evalExpr2(expr, { ...baseCtx, target }));
 };
 var evaluatePrecondition = ({
   expr,
@@ -1028,9 +1565,9 @@ var evaluatePrecondition = ({
   };
   const dependsOnTarget = expressionReferencesTarget(expr);
   if (!dependsOnTarget) {
-    return evalExpr(expr, { ...baseCtx, target: void 0 }) ? targets : [];
+    return evalExpr2(expr, { ...baseCtx, target: void 0 }) ? targets : [];
   }
-  return targets.filter((target) => evalExpr(expr, { ...baseCtx, target }));
+  return targets.filter((target) => evalExpr2(expr, { ...baseCtx, target }));
 };
 
 // src/apply-operation.ts
@@ -1352,6 +1889,12 @@ var deriveContext = ({
   const yesterdayDayOperations = timelines.filter((tl) => tl.turn === last.turn - 1 && tl.time === "day").flatMap((tl) => tl.operations ?? []);
   const yesterdayNightOperations = timelines.filter((tl) => tl.turn === last.turn - 1 && tl.time === "night").flatMap((tl) => tl.operations ?? []);
   const todayNominations = timelines.filter((tl) => tl.turn === last.turn && tl.time === "day").flatMap((tl) => tl.nominations ?? []).map((n) => ({ nominator: n.nominator, nominee: n.nominee }));
+  const yesterdayNominations = timelines.filter((tl) => tl.turn === last.turn - 1 && tl.time === "day").flatMap((tl) => tl.nominations ?? []).map((n) => ({ nominator: n.nominator, nominee: n.nominee }));
+  const allNominations = timelines.filter((tl) => tl.time === "day").flatMap((tl) => (tl.nominations ?? []).map((n) => ({
+    nominator: n.nominator,
+    nominee: n.nominee,
+    turn: tl.turn
+  })));
   return {
     currentTurn: last.turn,
     currentPhase: TIME_TO_PHASE[last.time],
@@ -1363,6 +1906,8 @@ var deriveContext = ({
     yesterdayDayOperations,
     yesterdayNightOperations,
     todayNominations,
+    yesterdayNominations,
+    allNominations,
     effectorSeat: candidate.effector,
     effector,
     abilityId: candidate.abilityId,
@@ -1371,6 +1916,14 @@ var deriveContext = ({
     operationTimeMap
   };
 };
+var nominationsForActionScope = (scope, ctx) => {
+  if (scope === "TONIGHT" || scope === "TODAY") return ctx.todayNominations;
+  if (scope === "YESTERDAY") return ctx.yesterdayNominations;
+  return ctx.allNominations.map((n) => ({ nominator: n.nominator, nominee: n.nominee }));
+};
+var extractPayloadSeats = (op) => (op.payloads ?? []).flatMap(
+  (v) => typeof v === "number" ? [v] : Array.isArray(v) ? v.filter((x) => typeof x === "number") : []
+);
 var operationsForActionScope = (scope, ctx) => {
   if (scope === "TONIGHT") return ctx.tonightOperations;
   if (scope === "TODAY") return ctx.todayOperations;
@@ -1426,23 +1979,37 @@ var evalAtomAction = (atom, ctx) => {
   if (subjectSeats.size === 0) return `no players match subject ${atom.subject.ref}`;
   const actorSeats = atom.actor ? seatsMatchingTargetRef(atom.actor, ctx) : null;
   if (atom.action === "NOMINATED") {
-    const noms = ctx.todayNominations;
+    const noms = nominationsForActionScope(atom.scope, ctx);
     const found = noms.some(
       (n) => subjectSeats.has(n.nominee) && (actorSeats === null || actorSeats.has(n.nominator))
     );
-    return found ? null : "no matching NOMINATED event in today";
+    return found ? null : "no matching NOMINATED event in scope";
+  }
+  if (atom.action === "NOMINATES") {
+    const noms = nominationsForActionScope(atom.scope, ctx);
+    const found = noms.some(
+      (n) => subjectSeats.has(n.nominator) && (actorSeats === null || actorSeats.has(n.nominee))
+    );
+    return found ? null : "no matching NOMINATES event in scope";
   }
   const scoped = operationsForActionScope(atom.scope, ctx);
   if (atom.action === "CHOSEN_AS_TARGET") {
     const found = scoped.some((op) => {
       if (actorSeats !== null && !actorSeats.has(op.effector)) return false;
-      const payloadSeats = (op.payloads ?? []).flatMap(
-        (v) => typeof v === "number" ? [v] : Array.isArray(v) ? v.filter((x) => typeof x === "number") : []
-      );
+      const payloadSeats = extractPayloadSeats(op);
       return payloadSeats.some((s) => subjectSeats.has(s));
     });
     return found ? null : "no matching CHOSEN_AS_TARGET in scope";
   }
+  if (atom.action === "CHOOSES_TARGET") {
+    const found = scoped.some((op) => {
+      if (!subjectSeats.has(op.effector)) return false;
+      if (actorSeats === null) return true;
+      const payloadSeats = extractPayloadSeats(op);
+      return payloadSeats.some((s) => actorSeats.has(s));
+    });
+    return found ? null : "no matching CHOOSES_TARGET in scope";
+  }
   const turnsInScope = (() => {
     if (atom.scope === "TONIGHT" || atom.scope === "TODAY") return [ctx.currentTurn];
     if (atom.scope === "YESTERDAY") return [ctx.currentTurn - 1];
@@ -1472,6 +2039,18 @@ var evalAtomAction = (atom, ctx) => {
     }
     return "no matching EXECUTED in scope";
   }
+  if (atom.action === "EXECUTES") {
+    const scopedNoms = atom.scope === "EVER" ? ctx.allNominations : atom.scope === "YESTERDAY" ? ctx.yesterdayNominations.map((n) => ({ ...n, turn: ctx.currentTurn - 1 })) : ctx.todayNominations.map((n) => ({ ...n, turn: ctx.currentTurn }));
+    const found = scopedNoms.some((n) => {
+      if (!subjectSeats.has(n.nominator)) return false;
+      if (actorSeats !== null && !actorSeats.has(n.nominee)) return false;
+      const executed = ctx.players.find(
+        (p) => p.seat === n.nominee && p.isDead && p.deathCause === "EXECUTION" && p.deathTurn === n.turn
+      );
+      return Boolean(executed);
+    });
+    return found ? null : "no matching EXECUTES in scope";
+  }
   void scoped;
   return `unknown action ${atom.action}`;
 };
@@ -1508,7 +2087,7 @@ var evalAtomGlobalCount = (atom, ctx) => {
   }
   return compareCount2(actual, atom.operator, atom.value) ? null : `global count ${atom.subject}=${actual} fails ${atom.operator} ${atom.value}`;
 };
-var evalAtom2 = (atom, ctx, customResolver) => {
+var evalAtom3 = (atom, ctx, customResolver) => {
   if (atom.type === "TIME") return evalAtomTime(atom, ctx);
   if (atom.type === "STATE") return evalAtomState(atom, ctx);
   if (atom.type === "ACTION") return evalAtomAction(atom, ctx);
@@ -1518,12 +2097,16 @@ var evalAtom2 = (atom, ctx, customResolver) => {
     if (!customResolver) return `no custom resolver registered for ${atom.resolverId}`;
     return customResolver({ resolverId: atom.resolverId, args: atom.args }, ctx) ? null : `custom resolver ${atom.resolverId} returned false`;
   }
+  if (atom.type === "DSL") {
+    const dslCtx = buildDslContextFromDerived(ctx);
+    return evalDslExpr(atom.expr, dslCtx) ? null : "DSL expression returned false";
+  }
   return "unknown atom";
 };
-var evalExpr2 = (expr, ctx, customResolver) => {
+var evalExpr3 = (expr, ctx, customResolver) => {
   if (expr.op === "AND") {
     for (const child of expr.children) {
-      const reason = evalExpr2(child, ctx, customResolver);
+      const reason = evalExpr3(child, ctx, customResolver);
       if (reason) return reason;
     }
     return null;
@@ -1531,17 +2114,17 @@ var evalExpr2 = (expr, ctx, customResolver) => {
   if (expr.op === "OR") {
     const reasons = [];
     for (const child of expr.children) {
-      const reason = evalExpr2(child, ctx, customResolver);
+      const reason = evalExpr3(child, ctx, customResolver);
       if (!reason) return null;
       reasons.push(reason);
     }
     return `OR: all branches failed (${reasons.join("; ")})`;
   }
   if (expr.op === "NOT") {
-    const reason = evalExpr2(expr.child, ctx, customResolver);
+    const reason = evalExpr3(expr.child, ctx, customResolver);
     return reason ? null : "NOT: inner expression was true";
   }
-  return evalAtom2(expr.atom, ctx, customResolver);
+  return evalAtom3(expr.atom, ctx, customResolver);
 };
 var canInvokeAbility = ({
   ability,
@@ -1561,23 +2144,47 @@ var canInvokeAbility = ({
   if (derived.effector?.retainsAbility === "ALL") {
     return { allowed: true };
   }
-  const reason = evalExpr2(window, derived, customResolver);
+  const reason = evalExpr3(window, derived, customResolver);
   return reason ? { allowed: false, reason } : { allowed: true };
 };
+
+// src/trigger-action.ts
+var ACTIVE_TRIGGER_ACTIONS = /* @__PURE__ */ new Set([
+  "NOMINATES",
+  "CHOOSES_TARGET",
+  "EXECUTES"
+]);
+var isActiveTriggerAction = (action) => ACTIVE_TRIGGER_ACTIONS.has(action);
 export {
+  ACTIVE_TRIGGER_ACTIONS,
+  DSL_CATALOG,
+  DSL_ITEM_FIELDS,
+  DSL_OPERATORS,
   adjustValueAsNumber,
   adjustValueAsNumberArray,
+  applyCountOperator,
   applyOperationToPlayers,
+  applyOperator,
+  buildDslContextFromDerived,
+  buildDslContextFromLifetime,
   buildPlayerSeatMap,
   canInvokeAbility,
   copyPlayers,
   deriveContext,
+  evalDslExpr,
+  evalExpr as evalDslExprWithBindings,
+  evaluatePath,
+  extendBindings,
   getSourceValue,
   getValueFromPayloads,
+  isActiveTriggerAction,
   isNumberOrNumberArray,
   isPlayerReminderArray,
   isReminder,
   resolveSourceValue,
   resolveTargetRef,
+  rootBindings,
+  traceDslExpr,
+  traceExpr,
   transformEmptyArray
 };