@ankhorage/zora 21.0.23 → 21.1.0

package/web-dist/chunks/Accordion-wg31jkvp.js

@@ -0,0 +1,1559 @@
+'use client';
+import {
+  require_cjs
+} from "./Accordion-cjht9dyv.js";
+import {
+  View2
+} from "./Accordion-t64m1kca.js";
+import {
+  __toESM
+} from "./Accordion-9qvmwkxe.js";
+
+// src/features/game/adapters/inbound/GameField.tsx
+var import_react_native = __toESM(require_cjs(), 1);
+import { jsx } from "react/jsx-runtime";
+function GameField2({
+  children,
+  aspectRatio,
+  minHeight = 320,
+  fill = false,
+  clip = true,
+  accessibilityLabel,
+  interactionPolicy,
+  testID
+}) {
+  return /* @__PURE__ */ jsx(View2, {
+    ...accessibilityLabel === undefined ? {} : { accessibilityLabel },
+    ...testID === undefined ? {} : { testID },
+    interactionPolicy,
+    pointerEvents: interactionPolicy === "passive" ? "none" : "auto",
+    style: [
+      styles.root,
+      clip ? styles.clipped : styles.overflowVisible,
+      fill ? styles.fill : undefined,
+      {
+        ...aspectRatio === undefined ? {} : { aspectRatio },
+        minHeight
+      }
+    ],
+    children
+  });
+}
+var styles = import_react_native.StyleSheet.create({
+  clipped: {
+    overflow: "hidden"
+  },
+  fill: {
+    flex: 1
+  },
+  overflowVisible: {
+    overflow: "visible"
+  },
+  root: {
+    position: "relative",
+    width: "100%"
+  }
+});
+// node_modules/@ankhorage/runtime/dist/RuntimeRendererConfig.js
+import React, { createContext, use } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var EMPTY_RUNTIME_RENDERER_CONFIG = {};
+var RuntimeRendererConfigContext = createContext(EMPTY_RUNTIME_RENDERER_CONFIG);
+function composeRuntimeRendererWrapNode(innerWrapNode, outerWrapNode) {
+  if (!innerWrapNode) {
+    return outerWrapNode;
+  }
+  if (!outerWrapNode) {
+    return innerWrapNode;
+  }
+  return (args) => outerWrapNode({ ...args, rendered: innerWrapNode(args) });
+}
+function composeRuntimeNodePropsResolver(localResolver, inheritedResolver) {
+  if (!localResolver) {
+    return inheritedResolver;
+  }
+  if (!inheritedResolver) {
+    return localResolver;
+  }
+  return (args) => {
+    const inheritedProps = inheritedResolver(args);
+    return localResolver({ ...args, props: inheritedProps });
+  };
+}
+function mergeRuntimeRendererConfig(localConfig, inheritedConfig) {
+  if (!localConfig && !inheritedConfig) {
+    return EMPTY_RUNTIME_RENDERER_CONFIG;
+  }
+  const actionHandlers = mergeRecordConfig(inheritedConfig?.actionHandlers, localConfig?.actionHandlers);
+  const bindingContext = mergeRecordConfig(inheritedConfig?.bindingContext, localConfig?.bindingContext);
+  const operationResults = mergeRecordConfig(inheritedConfig?.operationResults, localConfig?.operationResults);
+  return {
+    disableActions: localConfig?.disableActions === true || inheritedConfig?.disableActions === true,
+    registry: localConfig?.registry ?? inheritedConfig?.registry,
+    wrapNode: composeRuntimeRendererWrapNode(localConfig?.wrapNode, inheritedConfig?.wrapNode),
+    resolveNodeProps: composeRuntimeNodePropsResolver(localConfig?.resolveNodeProps, inheritedConfig?.resolveNodeProps),
+    resolveMediaAsset: localConfig?.resolveMediaAsset ?? inheritedConfig?.resolveMediaAsset,
+    mediaAssets: localConfig?.mediaAssets ?? inheritedConfig?.mediaAssets,
+    actionHandlers,
+    dbAdapter: localConfig?.dbAdapter ?? inheritedConfig?.dbAdapter,
+    dbRealtimeAdapter: localConfig?.dbRealtimeAdapter ?? inheritedConfig?.dbRealtimeAdapter,
+    stateAdapter: localConfig?.stateAdapter ?? inheritedConfig?.stateAdapter,
+    bindingContext,
+    apis: localConfig?.apis ?? inheritedConfig?.apis,
+    dataBindings: localConfig?.dataBindings ?? inheritedConfig?.dataBindings,
+    operationResults,
+    writeOperationResult: localConfig?.writeOperationResult ?? inheritedConfig?.writeOperationResult,
+    executeAction: localConfig?.executeAction ?? inheritedConfig?.executeAction,
+    executeOperation: localConfig?.executeOperation ?? inheritedConfig?.executeOperation,
+    onDiagnostics: localConfig?.onDiagnostics ?? inheritedConfig?.onDiagnostics,
+    eventOperationLifecycle: localConfig?.eventOperationLifecycle ?? inheritedConfig?.eventOperationLifecycle,
+    eventOperationState: localConfig?.eventOperationState ?? inheritedConfig?.eventOperationState
+  };
+}
+function RuntimeRendererConfigProvider(props) {
+  const { value, children } = props;
+  const inheritedConfig = use(RuntimeRendererConfigContext);
+  const mergedConfig = mergeRuntimeRendererConfig(value, inheritedConfig);
+  return /* @__PURE__ */ jsx2(RuntimeRendererConfigContext, {
+    value: mergedConfig,
+    children
+  });
+}
+function mergeRecordConfig(inherited, local) {
+  if (!inherited && !local)
+    return;
+  return {
+    ...inherited ?? {},
+    ...local ?? {}
+  };
+}
+// src/features/game/adapters/inbound/Game.tsx
+import React5 from "react";
+
+// src/features/game/composition/createGameBindingContext.ts
+function createGameBindingContext(session) {
+  return {
+    game: {
+      entities: Object.values(session.entities),
+      session
+    }
+  };
+}
+
+// src/features/game/composition/createGameMeasurementRegistry.ts
+function createGameMeasurementRegistry() {
+  const readers = new Map;
+  return {
+    registerMeasurement: (id, reader) => {
+      readers.set(id, reader);
+      return () => {
+        if (readers.get(id) === reader)
+          readers.delete(id);
+      };
+    },
+    measure: (id) => readers.get(id)?.() ?? Promise.resolve(undefined)
+  };
+}
+
+// src/features/game/composition/GameRuntimeContext.ts
+import React2 from "react";
+var GameRuntimeContext = React2.createContext(null);
+
+// node_modules/@ankhorage/game/dist/features/session/utils/gamePath.js
+function readGamePath(value, path) {
+  if (path === undefined || path.length === 0)
+    return value;
+  return path.split(".").reduce((current, segment) => {
+    if (current === undefined || current === null)
+      return;
+    if (isGameArray(current)) {
+      const index = Number(segment);
+      return Number.isInteger(index) ? current.at(index) : undefined;
+    }
+    if (typeof current !== "object")
+      return;
+    return readRecordEntry(current, segment);
+  }, value);
+}
+function writeGamePath(root, path, value) {
+  const segments = path.split(".").filter((segment) => segment.length > 0);
+  if (segments.length === 0)
+    throw new Error("Game state path must not be empty.");
+  return writeObjectPath(root, segments, value);
+}
+function readRecordEntry(record, key) {
+  return Object.entries(record).find(([entryKey]) => entryKey === key)?.[1];
+}
+function writeObjectPath(root, segments, value) {
+  const [segment, ...rest] = segments;
+  if (segment === undefined)
+    return root;
+  const nextValue = rest.length === 0 ? value : writeObjectPath(toRecord(readRecordEntry(root, segment)), rest, value);
+  return replaceRecordEntry(root, segment, nextValue);
+}
+function toRecord(value) {
+  if (value === null || value === undefined || typeof value !== "object" || isGameArray(value)) {
+    return {};
+  }
+  return value;
+}
+function isGameArray(value) {
+  return Array.isArray(value);
+}
+function replaceRecordEntry(root, key, value) {
+  return Object.fromEntries([
+    ...Object.entries(root).filter(([entryKey]) => entryKey !== key),
+    [key, value]
+  ]);
+}
+
+// node_modules/@ankhorage/game/dist/features/session/domain/evaluateGameExpression.js
+function evaluateGameExpression(expression, context) {
+  switch (expression.kind) {
+    case "literal":
+      return expression.value;
+    case "reference":
+      return resolveReference(expression.source, expression.path, context);
+    case "math":
+      return evaluateMath(expression.operator, expression.values, context);
+    case "clamp":
+      return Math.min(numberValue(evaluateGameExpression(expression.max, context)), Math.max(numberValue(evaluateGameExpression(expression.min, context)), numberValue(evaluateGameExpression(expression.value, context))));
+    case "split":
+      return splitValue(expression.value, expression.separator, context);
+    case "join":
+      return expression.values.map((value) => stringValue(evaluateGameExpression(value, context))).join(expression.separator ?? "");
+    case "entities":
+      return entityValues(context.session, expression.poolId);
+  }
+}
+function resolveReference(source, path, context) {
+  const sourceValue = referenceRoot(source, context);
+  const value = readGamePath(sourceValue, path);
+  if (value === undefined) {
+    throw new Error(`Game reference ${source}:${path ?? "<root>"} is undefined.`);
+  }
+  return value;
+}
+function referenceRoot(source, context) {
+  if (source === "state")
+    return context.session.state;
+  if (source === "input")
+    return context.input;
+  if (source === "local")
+    return context.local;
+  if (source === "entity") {
+    return context.entity === undefined ? undefined : entityValue(context.entity);
+  }
+  if (source === "event") {
+    return context.event === undefined ? undefined : eventValue(context.event);
+  }
+  return {
+    elapsedMs: context.session.elapsedMs,
+    phase: context.session.phase,
+    sequence: context.session.sequence,
+    stageId: context.session.stageId
+  };
+}
+function entityValue(entity) {
+  return {
+    ...entity.state,
+    id: entity.id,
+    templateId: entity.templateId,
+    ...entity.poolId === undefined ? {} : { poolId: entity.poolId }
+  };
+}
+function eventValue(event) {
+  return {
+    ...event.payload ?? {},
+    type: event.type,
+    ...event.entityId === undefined ? {} : { entityId: event.entityId },
+    ...event.seed === undefined ? {} : { seed: event.seed }
+  };
+}
+function entityValues(session, poolId) {
+  return Object.values(session.entities).filter((entity) => poolId === undefined || entity.poolId === poolId).map(entityValue);
+}
+function splitValue(expression, separator, context) {
+  const value = evaluateGameExpression(expression, context);
+  if (typeof value !== "string")
+    throw new Error("split expression requires a string value.");
+  return value.split(separator);
+}
+function stringValue(value) {
+  if (typeof value === "object" && value !== null) {
+    throw new Error("join expression accepts only scalar values.");
+  }
+  return String(value);
+}
+function evaluateMath(operator, expressions, context) {
+  const values = expressions.map((expression) => numberValue(evaluateGameExpression(expression, context)));
+  if (values.length === 0) {
+    throw new Error(`Math operator ${operator} requires at least one value.`);
+  }
+  if (operator === "add")
+    return values.reduce((total, value) => total + value, 0);
+  if (operator === "multiply")
+    return values.reduce((total, value) => total * value, 1);
+  if (operator === "min")
+    return Math.min(...values);
+  if (operator === "max")
+    return Math.max(...values);
+  const [first, ...rest] = values;
+  if (first === undefined)
+    throw new Error(`Math operator ${operator} requires a first value.`);
+  if (operator === "subtract")
+    return rest.reduce((result, value) => result - value, first);
+  return rest.reduce((result, value) => result / value, first);
+}
+function numberValue(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error("Game numeric expression resolved to a non-finite number.");
+  }
+  return value;
+}
+
+// node_modules/@ankhorage/game/dist/features/session/domain/applyEntityEffect.js
+function applyEntityEffect(definition, result, effect, contextSnapshot, context, applyNestedEffects) {
+  if (effect.kind === "spawnEntity")
+    return spawnEntity(definition, result, effect, context);
+  if (effect.kind === "removeEntity")
+    return removeEntity(result, effect.entityId, context);
+  if (effect.kind === "forEach") {
+    return forEachValue(result, effect, contextSnapshot, context, applyNestedEffects);
+  }
+  throw new Error(`Unsupported entity effect: ${effect.kind}`);
+}
+function spawnEntity(definition, result, effect, context) {
+  const template = definition.entityTemplates?.find((candidate) => candidate.id === effect.templateId);
+  if (template === undefined)
+    throw new Error(`Unknown entity template: ${effect.templateId}`);
+  const id = scalarId(evaluateGameExpression(effect.id, context), "spawnEntity id");
+  const mappedState = Object.entries(effect.state ?? {}).reduce((state, [key, expression]) => ({
+    ...state,
+    [key]: evaluateGameExpression(expression, context)
+  }), {});
+  const entity = {
+    id,
+    templateId: template.id,
+    state: { ...template.initialState ?? {}, ...mappedState }
+  };
+  const entities = Object.fromEntries([
+    ...Object.entries(result.session.entities).filter(([entityId]) => entityId !== id),
+    [id, entity]
+  ]);
+  return withSession(result, {
+    ...result.session,
+    entities,
+    sequence: result.session.sequence + 1
+  });
+}
+function removeEntity(result, idExpression, context) {
+  const id = scalarId(evaluateGameExpression(idExpression, context), "removeEntity id");
+  const entities = Object.fromEntries(Object.entries(result.session.entities).filter(([entityId]) => entityId !== id));
+  return withSession(result, { ...result.session, entities });
+}
+function forEachValue(result, effect, contextSnapshot, context, applyNestedEffects) {
+  const source = evaluateGameExpression(effect.source, context);
+  if (typeof source !== "string" && !isGameValueArray(source)) {
+    throw new Error("forEach source must be array or string.");
+  }
+  const values = typeof source === "string" ? [...source] : source;
+  return values.reduce((current, item, index) => {
+    const nested = applyNestedEffects(current.session, effect.effects, {
+      ...contextSnapshot,
+      local: { ...contextSnapshot.local ?? {}, item, index }
+    });
+    return {
+      session: nested.session,
+      outputs: [...current.outputs, ...nested.outputs]
+    };
+  }, result);
+}
+function isGameValueArray(value) {
+  return Array.isArray(value);
+}
+function scalarId(value, label) {
+  if (typeof value !== "string" && typeof value !== "number") {
+    throw new Error(`${label} must resolve to string or number.`);
+  }
+  return String(value);
+}
+function withSession(result, session) {
+  return { ...result, session };
+}
+
+// node_modules/@ankhorage/game/dist/features/session/domain/applyLifecycleEffect.js
+function applyLifecycleEffect(definition, result, effect, context) {
+  if (effect.kind === "transitionStage") {
+    return transitionStage(definition, result, effect.stageId, effect.clearEntities ?? true, context);
+  }
+  if (effect.kind === "restartStage") {
+    return restartStage(definition, result, effect.clearEntities ?? true);
+  }
+  throw new Error(`Unsupported lifecycle effect: ${effect.kind}`);
+}
+function transitionStage(definition, result, stageExpression, clearEntities, context) {
+  const currentStage = stageById(definition, result.session.stageId);
+  const stageIdValue = stageExpression === undefined ? currentStage.nextStageId : evaluateGameExpression(stageExpression, context);
+  if (typeof stageIdValue !== "string") {
+    throw new Error("transitionStage requires a target stage id.");
+  }
+  return withSession2(result, resetForStage(result.session, stageById(definition, stageIdValue), clearEntities));
+}
+function restartStage(definition, result, clearEntities) {
+  return withSession2(result, resetForStage(result.session, stageById(definition, result.session.stageId), clearEntities));
+}
+function resetForStage(session, stage, clearEntities) {
+  return {
+    ...session,
+    stageId: stage.id,
+    phase: "playing",
+    state: { ...session.state, ...stage.initialState ?? {} },
+    entities: clearEntities ? {} : session.entities,
+    scheduled: [],
+    sequence: session.sequence + 1
+  };
+}
+function stageById(definition, stageId) {
+  const stage = definition.stages.find((candidate) => candidate.id === stageId);
+  if (stage === undefined)
+    throw new Error(`Unknown game stage: ${stageId}`);
+  return stage;
+}
+function withSession2(result, session) {
+  return { ...result, session };
+}
+
+// node_modules/@ankhorage/game/dist/features/session/domain/evaluateGameCondition.js
+function evaluateGameCondition(condition, context) {
+  switch (condition.kind) {
+    case "all":
+      return condition.conditions.every((candidate) => evaluateGameCondition(candidate, context));
+    case "any":
+      return condition.conditions.some((candidate) => evaluateGameCondition(candidate, context));
+    case "not":
+      return !evaluateGameCondition(condition.condition, context);
+    case "truthy":
+      return Boolean(evaluateGameExpression(condition.value, context));
+    default: {
+      const left = evaluateGameExpression(condition.left, context);
+      const right = evaluateGameExpression(condition.right, context);
+      if (condition.kind === "equals")
+        return deepEquals(left, right);
+      if (condition.kind === "notEquals")
+        return !deepEquals(left, right);
+      if (condition.kind === "includes")
+        return includesValue(left, right);
+      const [leftNumber, rightNumber] = numericPair(left, right);
+      if (condition.kind === "greaterThan")
+        return leftNumber > rightNumber;
+      if (condition.kind === "greaterThanOrEqual")
+        return leftNumber >= rightNumber;
+      if (condition.kind === "lessThan")
+        return leftNumber < rightNumber;
+      return leftNumber <= rightNumber;
+    }
+  }
+}
+function deepEquals(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+function includesValue(container, value) {
+  if (typeof container === "string" && typeof value === "string")
+    return container.includes(value);
+  if (!Array.isArray(container))
+    return false;
+  return container.some((candidate) => deepEquals(candidate, value));
+}
+function numericPair(left, right) {
+  if (typeof left !== "number" || typeof right !== "number" || !Number.isFinite(left) || !Number.isFinite(right)) {
+    throw new Error("Numeric game condition requires two finite numbers.");
+  }
+  return [left, right];
+}
+
+// node_modules/@ankhorage/game/dist/features/session/domain/refreshGamePool.js
+function refreshGamePool(definition, session, input, poolId, seed) {
+  const pool = definition.pools?.find((candidate) => candidate.id === poolId);
+  if (pool === undefined)
+    throw new Error(`Unknown game pool: ${poolId}`);
+  const template = definition.entityTemplates?.find((candidate) => candidate.id === pool.entityTemplateId);
+  if (template === undefined)
+    throw new Error(`Unknown entity template: ${pool.entityTemplateId}`);
+  const source = evaluateGameExpression(pool.source, { session, input });
+  if (!Array.isArray(source)) {
+    throw new Error(`Game pool ${poolId} source must resolve to an array.`);
+  }
+  const excludedIds = collectExcludedIds(pool, session);
+  const rotated = rotate(source, seed).filter((item) => !excludedIds.has(readItemId(item, pool.idPath)));
+  const selected = selectItems(rotated, pool, session, input, seed);
+  const retained = Object.fromEntries(Object.entries(session.entities).filter(([, entity]) => entity.poolId !== poolId));
+  const generated = selected.reduce((entries, item, index) => {
+    const itemId = readItemId(item, pool.idPath);
+    const local = localContext(item, index, seed);
+    const state = buildEntityState(template.initialState ?? {}, pool, session, input, local);
+    const priorStates = entries.map(([, entity]) => entity.state);
+    const placedState = placeEntity(state, pool, priorStates, index, seed);
+    const id = `${pool.id}:${itemId}:${session.sequence + index + 1}`;
+    const entity = {
+      id,
+      templateId: template.id,
+      poolId: pool.id,
+      state: placedState
+    };
+    return [...entries, [id, entity]];
+  }, []);
+  return { ...retained, ...Object.fromEntries(generated) };
+}
+function collectExcludedIds(pool, session) {
+  const values = (pool.excludeIdsFromStatePaths ?? []).flatMap((path) => {
+    const value = readGamePath(session.state, path);
+    return Array.isArray(value) ? value.filter(isScalarId) : [];
+  });
+  return new Set(values);
+}
+function selectItems(source, pool, session, input, seed) {
+  const selected = pool.selectors.reduce((current, selector) => {
+    const candidates = source.filter((item) => {
+      if (current.some((existing) => readItemId(existing, pool.idPath) === readItemId(item, pool.idPath))) {
+        return false;
+      }
+      if (selector.where === undefined)
+        return true;
+      return evaluateGameCondition(selector.where, { session, input, local: { item, seed } });
+    });
+    return [...current, ...candidates.slice(0, selector.count)];
+  }, []);
+  if (selected.length !== pool.size) {
+    throw new Error(`Game pool ${pool.id} selected ${selected.length} items; expected ${pool.size}.`);
+  }
+  return selected;
+}
+function buildEntityState(initialState, pool, session, input, local) {
+  const mapped = Object.entries(pool.entityState ?? {}).reduce((state, [key, expression]) => ({
+    ...state,
+    [key]: evaluateGameExpression(expression, { session, input, local })
+  }), {});
+  return { ...initialState, data: local.item ?? null, ...mapped };
+}
+function placeEntity(state, pool, priorStates, index, seed) {
+  const { placement } = pool;
+  if (placement === undefined)
+    return state;
+  const priorPositions = priorStates.flatMap((priorState) => {
+    const x = readGamePath(priorState, placement.xStatePath);
+    const y = readGamePath(priorState, placement.yStatePath);
+    return typeof x === "number" && typeof y === "number" ? [{ x, y }] : [];
+  });
+  const point = Array.from({ length: 32 }, (_, attempt) => deterministicPoint(placement, index + attempt * 17, seed)).find((candidate) => priorPositions.every((prior) => Math.hypot(candidate.x - prior.x, candidate.y - prior.y) >= (placement.minimumDistance ?? 0))) ?? deterministicPoint(placement, index, seed);
+  return writeGamePath(writeGamePath(state, placement.xStatePath, point.x), placement.yStatePath, point.y);
+}
+function deterministicPoint(placement, sequence, seed) {
+  const xRatio = fractional(seed + (sequence + 1) * 0.61803398875);
+  const yRatio = fractional(seed + (sequence + 1) * 0.41421356237);
+  return {
+    x: placement.xMin + xRatio * (placement.xMax - placement.xMin),
+    y: placement.yMin + yRatio * (placement.yMax - placement.yMin)
+  };
+}
+function rotate(values, seed) {
+  if (values.length === 0)
+    return values;
+  const offset = Math.floor(fractional(seed) * values.length);
+  return [...values.slice(offset), ...values.slice(0, offset)];
+}
+function localContext(item, index, seed) {
+  return { item, index, seed, random: fractional(seed + (index + 1) * 0.754877666) };
+}
+function readItemId(item, idPath = "id") {
+  const id = readGamePath(item, idPath);
+  if (!isScalarId(id)) {
+    throw new Error(`Game pool item id at ${idPath} must be a string or number.`);
+  }
+  return id;
+}
+function isScalarId(value) {
+  return typeof value === "string" || typeof value === "number";
+}
+function fractional(value) {
+  const finite = Number.isFinite(value) ? value : 0;
+  return (finite % 1 + 1) % 1;
+}
+
+// node_modules/@ankhorage/game/dist/features/session/domain/applyStateEffect.js
+function applyStateEffect(definition, result, effect, input, contextSnapshot, context) {
+  switch (effect.kind) {
+    case "set":
+      return withSession3(result, {
+        ...result.session,
+        state: writeGamePath(result.session.state, effect.path, evaluateGameExpression(effect.value, context))
+      });
+    case "append":
+      return appendState(result, effect, context);
+    case "increment":
+      return incrementState(result, effect, context);
+    case "setPhase":
+      return setPhase(result, effect.phase, context);
+    case "emit":
+      return emitOutput(result, effect.type, effect.payload, context);
+    case "schedule":
+      return scheduleEffects(result, effect, context, contextSnapshot);
+    case "refreshPool":
+      return refreshPool(definition, result, effect, input, contextSnapshot, context);
+    default:
+      throw new Error(`Unsupported state effect: ${effect.kind}`);
+  }
+}
+function appendState(result, effect, context) {
+  const current = readGamePath(result.session.state, effect.path);
+  if (current !== undefined && !isGameValueArray2(current)) {
+    throw new Error(`append requires array state at ${effect.path}.`);
+  }
+  if (effect.maxLength !== undefined && (!Number.isInteger(effect.maxLength) || effect.maxLength < 0)) {
+    throw new Error("append maxLength must be a non-negative integer.");
+  }
+  const appended = [...current ?? [], evaluateGameExpression(effect.value, context)];
+  const next = effect.maxLength === undefined ? appended : appended.slice(-effect.maxLength);
+  return withSession3(result, {
+    ...result.session,
+    state: writeGamePath(result.session.state, effect.path, next)
+  });
+}
+function isGameValueArray2(value) {
+  return Array.isArray(value);
+}
+function incrementState(result, effect, context) {
+  const current = readGamePath(result.session.state, effect.path);
+  const amount = evaluateGameExpression(effect.value, context);
+  if (typeof current !== "number" || typeof amount !== "number") {
+    throw new Error(`increment requires numeric state at ${effect.path}.`);
+  }
+  const min = effect.min === undefined ? Number.NEGATIVE_INFINITY : numeric(effect.min, context);
+  const max = effect.max === undefined ? Number.POSITIVE_INFINITY : numeric(effect.max, context);
+  return withSession3(result, {
+    ...result.session,
+    state: writeGamePath(result.session.state, effect.path, Math.min(max, Math.max(min, current + amount)))
+  });
+}
+function numeric(expression, context) {
+  const value = evaluateGameExpression(expression, context);
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error("Expected numeric game expression.");
+  }
+  return value;
+}
+function setPhase(result, phaseExpression, context) {
+  const phase = evaluateGameExpression(phaseExpression, context);
+  if (typeof phase !== "string")
+    throw new Error("setPhase requires a string expression.");
+  return withSession3(result, { ...result.session, phase });
+}
+function emitOutput(result, type, payloadDefinition, context) {
+  const payload = Object.entries(payloadDefinition ?? {}).reduce((record, [key, expression]) => ({
+    ...record,
+    [key]: evaluateGameExpression(expression, context)
+  }), {});
+  const output = { type, payload };
+  return { ...result, outputs: [...result.outputs, output] };
+}
+function scheduleEffects(result, effect, context, contextSnapshot) {
+  const delayMs = evaluateGameExpression(effect.delayMs, context);
+  if (typeof delayMs !== "number" || delayMs < 0) {
+    throw new Error("schedule delay must be non-negative.");
+  }
+  const scheduled = {
+    id: result.session.sequence + result.session.scheduled.length + 1,
+    remainingMs: delayMs,
+    effects: effect.effects,
+    context: contextSnapshot
+  };
+  return withSession3(result, {
+    ...result.session,
+    scheduled: [...result.session.scheduled, scheduled]
+  });
+}
+function refreshPool(definition, result, effect, input, contextSnapshot, context) {
+  const seedValue = effect.seed === undefined ? contextSnapshot.event?.seed ?? result.session.sequence : evaluateGameExpression(effect.seed, context);
+  if (typeof seedValue !== "number")
+    throw new Error("refreshPool seed must be numeric.");
+  return withSession3(result, {
+    ...result.session,
+    entities: refreshGamePool(definition, result.session, input, effect.poolId, seedValue),
+    sequence: result.session.sequence + 1
+  });
+}
+function withSession3(result, session) {
+  return { ...result, session };
+}
+
+// node_modules/@ankhorage/game/dist/features/session/domain/applyGameEffects.js
+function applyGameEffects(definition, session, effects, input, contextSnapshot = {}) {
+  return effects.reduce((result, effect) => applyEffect(definition, result, effect, input, contextSnapshot), { session, outputs: [] });
+}
+function applyEffect(definition, result, effect, input, contextSnapshot) {
+  const context = createExpressionContext(result.session, input, contextSnapshot);
+  if (isEntityEffect(effect)) {
+    return applyEntityEffect(definition, result, effect, contextSnapshot, context, (nestedSession, nestedEffects, nestedContext) => applyGameEffects(definition, nestedSession, nestedEffects, input, nestedContext));
+  }
+  if (isLifecycleEffect(effect)) {
+    return applyLifecycleEffect(definition, result, effect, context);
+  }
+  return applyStateEffect(definition, result, effect, input, contextSnapshot, context);
+}
+function createExpressionContext(session, input, contextSnapshot) {
+  const entity = contextSnapshot.entityId === undefined ? undefined : Object.values(session.entities).find((candidate) => candidate.id === contextSnapshot.entityId);
+  return {
+    session,
+    input,
+    ...contextSnapshot.event === undefined ? {} : { event: contextSnapshot.event },
+    ...entity === undefined ? {} : { entity },
+    ...contextSnapshot.local === undefined ? {} : { local: contextSnapshot.local }
+  };
+}
+function isEntityEffect(effect) {
+  return effect.kind === "spawnEntity" || effect.kind === "removeEntity" || effect.kind === "forEach";
+}
+function isLifecycleEffect(effect) {
+  return effect.kind === "transitionStage" || effect.kind === "restartStage";
+}
+
+// node_modules/@ankhorage/game/dist/features/session/application/use-cases/advanceGameTime.js
+function advanceGameTime(definition, session, elapsedMs, input = {}) {
+  if (!Number.isFinite(elapsedMs) || elapsedMs < 0) {
+    throw new Error("Game elapsed time must be a non-negative finite number.");
+  }
+  const scheduled = session.scheduled.map((candidate) => ({
+    ...candidate,
+    remainingMs: candidate.remainingMs - elapsedMs
+  }));
+  const advanced = {
+    ...session,
+    elapsedMs: session.elapsedMs + elapsedMs,
+    scheduled: scheduled.filter((candidate) => candidate.remainingMs > 0)
+  };
+  const due = scheduled.filter((candidate) => candidate.remainingMs <= 0).sort((left, right) => left.id - right.id);
+  return due.reduce((result, candidate) => executeScheduled(definition, result, candidate, input), { session: advanced, outputs: [] });
+}
+function executeScheduled(definition, result, scheduled, input) {
+  const applied = applyGameEffects(definition, result.session, scheduled.effects, input, scheduled.context);
+  return { session: applied.session, outputs: [...result.outputs, ...applied.outputs] };
+}
+// node_modules/@ankhorage/game/dist/features/session/application/use-cases/applyGameEvent.js
+function applyGameEvent(definition, session, event, input = {}) {
+  if (session.definitionId !== definition.id) {
+    throw new Error(`Session belongs to ${session.definitionId}, not ${definition.id}.`);
+  }
+  const entity = event.entityId === undefined ? undefined : session.entities[event.entityId];
+  return definition.rules.filter((rule) => rule.event === event.type).reduce((result, rule) => {
+    const currentEntity = event.entityId === undefined ? undefined : result.session.entities[event.entityId];
+    const ruleEntity = currentEntity ?? entity;
+    const conditionContext = {
+      session: result.session,
+      input,
+      event,
+      ...ruleEntity === undefined ? {} : { entity: ruleEntity }
+    };
+    const matches = rule.when === undefined || evaluateGameCondition(rule.when, conditionContext);
+    if (!matches)
+      return result;
+    const applied = applyGameEffects(definition, result.session, rule.effects, input, {
+      event,
+      ...event.entityId === undefined ? {} : { entityId: event.entityId }
+    });
+    return { session: applied.session, outputs: [...result.outputs, ...applied.outputs] };
+  }, { session, outputs: [] });
+}
+// node_modules/@ankhorage/game/dist/features/session/application/use-cases/createGameSession.js
+function createGameSession(definition, initialization = {}) {
+  const firstStage = definition.stages.at(0);
+  if (firstStage === undefined)
+    throw new Error("Game definition requires at least one stage.");
+  const { input = {}, seed = 0 } = initialization;
+  if (!Number.isFinite(seed))
+    throw new Error("Game session seed must be finite.");
+  const session = {
+    definitionId: definition.id,
+    stageId: firstStage.id,
+    phase: definition.initialPhase ?? "playing",
+    state: { ...definition.initialState ?? {}, ...firstStage.initialState ?? {} },
+    entities: {},
+    scheduled: [],
+    elapsedMs: 0,
+    sequence: 0
+  };
+  return applyGameEvent(definition, session, { type: "game.start", seed }, input);
+}
+// src/features/game/composition/useGameRuntime.ts
+import React4 from "react";
+
+// src/features/game/composition/useGameScheduledEffects.ts
+import React3 from "react";
+function useGameScheduledEffects({
+  clockRef,
+  definitionRef,
+  enabled,
+  inputRef,
+  runtimeKey,
+  scheduled,
+  setRuntime
+}) {
+  React3.useEffect(() => {
+    if (!enabled || scheduled.length === 0)
+      return;
+    const delayMs = resolveNextScheduledDelay(scheduled);
+    const timer = setTimeout(() => {
+      const now = Date.now();
+      const elapsedMs = Math.max(0, now - clockRef.current);
+      clockRef.current = now;
+      setRuntime((current) => advanceScheduledRuntime({
+        current,
+        definition: definitionRef.current,
+        elapsedMs,
+        input: inputRef.current,
+        runtimeKey
+      }));
+    }, delayMs);
+    return () => clearTimeout(timer);
+  }, [clockRef, definitionRef, enabled, inputRef, runtimeKey, scheduled, setRuntime]);
+}
+function advanceScheduledRuntime({
+  current,
+  definition,
+  elapsedMs,
+  input,
+  runtimeKey
+}) {
+  if (current.key !== runtimeKey)
+    return current;
+  const result = advanceGameTime(definition, current.session, elapsedMs, input);
+  return {
+    key: runtimeKey,
+    session: result.session,
+    outputs: [...current.outputs, ...result.outputs],
+    revision: current.revision + 1
+  };
+}
+function resolveNextScheduledDelay(scheduledEffects) {
+  return scheduledEffects.reduce((nearest, scheduled) => Math.min(nearest, scheduled.remainingMs), Number.POSITIVE_INFINITY);
+}
+
+// src/features/game/composition/useGameRuntime.ts
+var EMPTY_GAME_INPUT = {};
+function useGameRuntime(props) {
+  const { definition, input = EMPTY_GAME_INPUT, seed = 0, resetKey = "" } = props;
+  const definitionRef = useLatestValue(definition);
+  const inputRef = useLatestValue(input);
+  const outputRef = useLatestValue(props.onOutput);
+  const autoAdvanceTime = props.autoAdvanceTime ?? true;
+  const clockRef = React4.useRef(0);
+  const runtimeKey = createRuntimeKey(definition.id, resetKey, seed);
+  const [runtime, setRuntime] = React4.useState(() => createRuntimeState(definition, input, seed, runtimeKey, 0));
+  useGameRuntimeReset({
+    clockRef,
+    definitionRef,
+    inputRef,
+    runtimeKey,
+    seed,
+    setRuntime
+  });
+  useGameAutoAdvanceClock(autoAdvanceTime, clockRef);
+  useGameOutputEmitter(runtime, outputRef, setRuntime);
+  const dispatch = React4.useCallback((event) => {
+    const now = Date.now();
+    setRuntime((current) => applyRuntimeEvent({
+      autoAdvanceTime,
+      current,
+      definition: definitionRef.current,
+      elapsedMs: Math.max(0, now - clockRef.current),
+      event,
+      input: inputRef.current,
+      runtimeKey,
+      seed
+    }));
+    clockRef.current = now;
+  }, [autoAdvanceTime, definitionRef, inputRef, runtimeKey, seed]);
+  useGameScheduledEffects({
+    clockRef,
+    definitionRef,
+    enabled: autoAdvanceTime,
+    inputRef,
+    runtimeKey,
+    scheduled: runtime.session.scheduled,
+    setRuntime
+  });
+  return React4.useMemo(() => ({ session: runtime.session, dispatch }), [dispatch, runtime.session]);
+}
+function useGameRuntimeReset({
+  clockRef,
+  definitionRef,
+  inputRef,
+  runtimeKey,
+  seed,
+  setRuntime
+}) {
+  React4.useEffect(() => {
+    clockRef.current = Date.now();
+    setRuntime((current) => current.key === runtimeKey ? current : createRuntimeState(definitionRef.current, inputRef.current, seed, runtimeKey, current.revision + 1));
+  }, [clockRef, definitionRef, inputRef, runtimeKey, seed, setRuntime]);
+}
+function useGameAutoAdvanceClock(enabled, clockRef) {
+  const previousEnabledRef = React4.useRef(enabled);
+  React4.useEffect(() => {
+    if (enabled && !previousEnabledRef.current) {
+      clockRef.current = Date.now();
+    }
+    previousEnabledRef.current = enabled;
+  }, [clockRef, enabled]);
+}
+function useGameOutputEmitter(runtime, outputRef, setRuntime) {
+  React4.useEffect(() => {
+    if (runtime.outputs.length === 0)
+      return;
+    setRuntime((current) => current.revision === runtime.revision ? { ...current, outputs: [] } : current);
+    emitGameOutputs(runtime.outputs, outputRef.current);
+  }, [outputRef, runtime.outputs, runtime.revision, setRuntime]);
+}
+function applyRuntimeEvent(args) {
+  const base = args.current.key === args.runtimeKey ? args.current : createRuntimeState(args.definition, args.input, args.seed, args.runtimeKey, args.current.revision);
+  const timed = args.autoAdvanceTime ? advanceGameTime(args.definition, base.session, args.elapsedMs, args.input) : { session: base.session, outputs: [] };
+  const result = applyGameEvent(args.definition, timed.session, args.event, args.input);
+  return {
+    key: args.runtimeKey,
+    session: result.session,
+    outputs: [...base.outputs, ...timed.outputs, ...result.outputs],
+    revision: args.current.revision + 1
+  };
+}
+function createRuntimeState(definition, input, seed, key, revision) {
+  const result = createGameSession(definition, { input, seed });
+  return { key, session: result.session, outputs: result.outputs, revision };
+}
+function createRuntimeKey(definitionId, resetKey, seed) {
+  return `${definitionId}:${resetKey}:${seed}`;
+}
+function emitGameOutputs(outputs, onOutput) {
+  if (onOutput === undefined)
+    return;
+  outputs.forEach((output) => onOutput(output));
+}
+function useLatestValue(value) {
+  const ref = React4.useRef(value);
+  React4.useEffect(() => {
+    ref.current = value;
+  }, [value]);
+  return ref;
+}
+
+// src/features/game/adapters/inbound/Game.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+function Game2(props) {
+  const runtime = useGameRuntime(props);
+  const [measurementRegistry] = React5.useState(createGameMeasurementRegistry);
+  const runtimeContext = React5.useMemo(() => ({ ...runtime, ...measurementRegistry, interactionPolicy: props.interactionPolicy }), [measurementRegistry, props.interactionPolicy, runtime]);
+  const runtimeBindingConfig = React5.useMemo(() => ({ bindingContext: createGameBindingContext(runtime.session) }), [runtime.session]);
+  return /* @__PURE__ */ jsx3(GameRuntimeContext.Provider, {
+    value: runtimeContext,
+    children: /* @__PURE__ */ jsx3(RuntimeRendererConfigProvider, {
+      value: runtimeBindingConfig,
+      children: /* @__PURE__ */ jsx3(GameField2, {
+        ...props.aspectRatio === undefined ? {} : { aspectRatio: props.aspectRatio },
+        ...props.minHeight === undefined ? {} : { minHeight: props.minHeight },
+        ...props.fill === undefined ? {} : { fill: props.fill },
+        ...props.clip === undefined ? {} : { clip: props.clip },
+        ...props.accessibilityLabel === undefined ? {} : { accessibilityLabel: props.accessibilityLabel },
+        ...props.testID === undefined ? {} : { testID: props.testID },
+        interactionPolicy: props.interactionPolicy,
+        children: props.children
+      })
+    })
+  });
+}
+
+// src/features/game/adapters/inbound/GameEntity.tsx
+var import_react_native6 = __toESM(require_cjs(), 1);
+import React10 from "react";
+
+// src/features/game/utils/useGameEntityAnimatedStyle.ts
+var import_react_native5 = __toESM(require_cjs(), 1);
+
+// src/features/game/utils/resolveGameEntityMotionPlan.ts
+function resolveGameEntityMotionPlan(props, reduceMotion) {
+  const essential = props.motionEssential === true;
+  const motionEnabled = hasMotionOffset(props) && normalizeDuration(props.motionDurationMs) > 0 && (!reduceMotion || essential);
+  return {
+    transitionDurationMs: reduceMotion ? 0 : normalizeDuration(props.transitionDurationMs),
+    transitionEasing: props.transitionEasing ?? "linear",
+    motionDurationMs: normalizeDuration(props.motionDurationMs),
+    motionDelayMs: normalizeDuration(props.motionDelayMs),
+    motionEasing: props.motionEasing ?? "linear",
+    motionEnabled,
+    motionRepeat: props.motionRepeat === true,
+    motionAlternate: props.motionRepeat === true && props.motionAlternate === true,
+    motionPaused: props.motionPaused === true
+  };
+}
+function hasMotionOffset(props) {
+  return (props.motionOffsetX ?? 0) !== 0 || (props.motionOffsetY ?? 0) !== 0 || (props.motionOpacityDelta ?? 0) !== 0 || (props.motionScaleDelta ?? 0) !== 0 || (props.motionRotationDelta ?? 0) !== 0;
+}
+function normalizeDuration(value) {
+  return value === undefined || !Number.isFinite(value) ? 0 : Math.max(0, value);
+}
+
+// src/features/game/utils/useAnimatedGameEntityValue.ts
+var import_react_native2 = __toESM(require_cjs(), 1);
+import React6 from "react";
+function useAnimatedGameEntityValue(target, durationMs, easing) {
+  const [value] = React6.useState(() => new import_react_native2.Animated.Value(target));
+  React6.useEffect(() => {
+    value.stopAnimation();
+    if (durationMs === 0) {
+      value.setValue(target);
+      return;
+    }
+    const animation = import_react_native2.Animated.timing(value, {
+      toValue: target,
+      duration: durationMs,
+      easing: resolveGameEntityEasing(easing),
+      useNativeDriver: false
+    });
+    animation.start();
+    return () => animation.stop();
+  }, [durationMs, easing, target, value]);
+  return value;
+}
+function resolveGameEntityEasing(easing) {
+  if (easing === "ease-in")
+    return import_react_native2.Easing.in(import_react_native2.Easing.ease);
+  if (easing === "ease-out")
+    return import_react_native2.Easing.out(import_react_native2.Easing.ease);
+  if (easing === "ease-in-out")
+    return import_react_native2.Easing.inOut(import_react_native2.Easing.ease);
+  return import_react_native2.Easing.linear;
+}
+
+// src/features/game/utils/useGameEntityMotionProgress.ts
+var import_react_native3 = __toESM(require_cjs(), 1);
+import React7 from "react";
+function useGameEntityMotionProgress(plan) {
+  const [progress] = React7.useState(() => new import_react_native3.Animated.Value(0));
+  const signature = createMotionSignature(plan);
+  const previousSignature = React7.useRef(signature);
+  const {
+    motionEnabled,
+    motionPaused,
+    motionDurationMs,
+    motionDelayMs,
+    motionEasing,
+    motionRepeat,
+    motionAlternate
+  } = plan;
+  React7.useEffect(() => {
+    progress.stopAnimation();
+    if (!motionEnabled) {
+      progress.setValue(0);
+      return;
+    }
+    if (previousSignature.current !== signature) {
+      progress.setValue(0);
+      previousSignature.current = signature;
+    }
+    if (motionPaused)
+      return;
+    const animation = createMotionAnimation(progress, {
+      durationMs: motionDurationMs,
+      delayMs: motionDelayMs,
+      easing: motionEasing,
+      repeat: motionRepeat,
+      alternate: motionAlternate
+    });
+    animation.start();
+    return () => animation.stop();
+  }, [
+    motionAlternate,
+    motionDelayMs,
+    motionDurationMs,
+    motionEasing,
+    motionEnabled,
+    motionPaused,
+    motionRepeat,
+    progress,
+    signature
+  ]);
+  return progress;
+}
+function createMotionAnimation(progress, input) {
+  const forward = () => import_react_native3.Animated.timing(progress, {
+    toValue: 1,
+    duration: input.durationMs,
+    easing: resolveMotionEasing(input.easing),
+    useNativeDriver: false
+  });
+  const reverse = () => import_react_native3.Animated.timing(progress, {
+    toValue: 0,
+    duration: input.durationMs,
+    easing: resolveMotionEasing(input.easing),
+    useNativeDriver: false
+  });
+  const movement = input.alternate ? import_react_native3.Animated.loop(import_react_native3.Animated.sequence([forward(), reverse()])) : input.repeat ? import_react_native3.Animated.loop(forward()) : forward();
+  return input.delayMs === 0 ? movement : import_react_native3.Animated.sequence([import_react_native3.Animated.delay(input.delayMs), movement]);
+}
+function createMotionSignature(plan) {
+  return [
+    plan.motionDurationMs,
+    plan.motionDelayMs,
+    plan.motionEasing,
+    plan.motionEnabled,
+    plan.motionRepeat,
+    plan.motionAlternate
+  ].join(":");
+}
+function resolveMotionEasing(easing) {
+  if (easing === "ease-in")
+    return import_react_native3.Easing.in(import_react_native3.Easing.ease);
+  if (easing === "ease-out")
+    return import_react_native3.Easing.out(import_react_native3.Easing.ease);
+  if (easing === "ease-in-out")
+    return import_react_native3.Easing.inOut(import_react_native3.Easing.ease);
+  return import_react_native3.Easing.linear;
+}
+
+// src/features/game/utils/useGameReducedMotion.ts
+var import_react_native4 = __toESM(require_cjs(), 1);
+import React8 from "react";
+function useGameReducedMotion() {
+  const [reduceMotion, setReduceMotion] = React8.useState(false);
+  React8.useEffect(() => {
+    import_react_native4.AccessibilityInfo.isReduceMotionEnabled().then(setReduceMotion);
+    const subscription = import_react_native4.AccessibilityInfo.addEventListener("reduceMotionChanged", setReduceMotion);
+    return () => subscription.remove();
+  }, []);
+  return reduceMotion;
+}
+
+// src/features/game/utils/useGameEntityAnimatedStyle.ts
+function useGameEntityAnimatedStyle(input) {
+  const reduceMotion = useGameReducedMotion();
+  const plan = resolveGameEntityMotionPlan(input, reduceMotion);
+  const values = {
+    x: useAnimatedGameEntityValue(input.x ?? 0, plan.transitionDurationMs, plan.transitionEasing),
+    y: useAnimatedGameEntityValue(input.y ?? 0, plan.transitionDurationMs, plan.transitionEasing),
+    opacity: useAnimatedGameEntityValue(input.opacity ?? 1, plan.transitionDurationMs, plan.transitionEasing),
+    scale: useAnimatedGameEntityValue(input.scale ?? 1, plan.transitionDurationMs, plan.transitionEasing),
+    rotation: useAnimatedGameEntityValue(input.rotation ?? 0, plan.transitionDurationMs, plan.transitionEasing),
+    progress: useGameEntityMotionProgress(plan)
+  };
+  return createGameEntityAnimatedStyle(values, input);
+}
+function createGameEntityAnimatedStyle(values, input) {
+  const left = import_react_native5.Animated.add(values.x, import_react_native5.Animated.multiply(values.progress, input.motionOffsetX ?? 0));
+  const top = import_react_native5.Animated.add(values.y, import_react_native5.Animated.multiply(values.progress, input.motionOffsetY ?? 0));
+  const opacity = import_react_native5.Animated.add(values.opacity, import_react_native5.Animated.multiply(values.progress, input.motionOpacityDelta ?? 0));
+  const scale = import_react_native5.Animated.add(values.scale, import_react_native5.Animated.multiply(values.progress, input.motionScaleDelta ?? 0));
+  const rotation = import_react_native5.Animated.add(values.rotation, import_react_native5.Animated.multiply(values.progress, input.motionRotationDelta ?? 0));
+  return {
+    left: left.interpolate({
+      inputRange: [-1e4, 1e4],
+      outputRange: ["-10000%", "10000%"]
+    }),
+    top: top.interpolate({
+      inputRange: [-1e4, 1e4],
+      outputRange: ["-10000%", "10000%"]
+    }),
+    opacity: opacity.interpolate({
+      inputRange: [0, 1],
+      outputRange: [0, 1],
+      extrapolate: "clamp"
+    }),
+    transform: [
+      { scale },
+      {
+        rotate: rotation.interpolate({
+          inputRange: [-36000, 36000],
+          outputRange: ["-36000deg", "36000deg"]
+        })
+      }
+    ]
+  };
+}
+
+// src/features/game/utils/useGameEntityMeasurement.ts
+import React9 from "react";
+
+// src/features/game/adapters/inbound/measureGameEntity.ts
+function measureGameEntity(element) {
+  if (element === null)
+    return Promise.resolve(undefined);
+  return new Promise((resolve) => {
+    element.measureInWindow((left, top, width, height) => {
+      if (![left, top, width, height].every(Number.isFinite) || width < 0 || height < 0) {
+        resolve(undefined);
+        return;
+      }
+      resolve({
+        left,
+        right: left + width,
+        top,
+        bottom: top + height,
+        width,
+        height
+      });
+    });
+  });
+}
+
+// src/features/game/utils/useGameEntityMeasurement.ts
+function useGameEntityMeasurement(elementRef, measurementId) {
+  const runtime = React9.useContext(GameRuntimeContext);
+  const registerMeasurement = runtime?.registerMeasurement;
+  React9.useEffect(() => {
+    if (measurementId === undefined || registerMeasurement === undefined)
+      return;
+    return registerMeasurement(measurementId, () => measureGameEntity(elementRef.current));
+  }, [elementRef, measurementId, registerMeasurement]);
+}
+
+// src/features/game/adapters/inbound/GameEntity.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+function GameEntity2(props) {
+  const elementRef = React10.useRef(null);
+  const animatedStyle = useGameEntityAnimatedStyle(props);
+  useGameEntityMeasurement(elementRef, props.measurementId);
+  return /* @__PURE__ */ jsx4(import_react_native6.Animated.View, {
+    ref: elementRef,
+    accessibilityLabel: props.accessibilityLabel,
+    testID: props.testID,
+    pointerEvents: props.interactionPolicy === "passive" ? "none" : props.pointerEvents ?? "auto",
+    style: [styles2.root, createEntityStaticStyle(props), animatedStyle],
+    children: props.children
+  });
+}
+function createEntityStaticStyle(props) {
+  return {
+    display: props.hidden === true ? "none" : "flex",
+    position: "absolute",
+    zIndex: props.zIndex ?? 0,
+    ...props.height === undefined ? {} : { height: props.height },
+    ...props.width === undefined ? {} : { width: props.width }
+  };
+}
+var styles2 = import_react_native6.StyleSheet.create({
+  root: {
+    position: "absolute"
+  }
+});
+
+// src/features/game/adapters/inbound/GameInputZone.tsx
+var import_react_native7 = __toESM(require_cjs(), 1);
+
+// src/features/game/utils/clampGamePercentage.ts
+function clampGamePercentage(value) {
+  return Math.min(100, Math.max(0, value));
+}
+
+// src/features/game/utils/toGamePercentage.ts
+function toGamePercentage(value) {
+  return `${clampGamePercentage(value)}%`;
+}
+
+// src/features/game/adapters/inbound/useGameInputZoneResponder.ts
+import React11 from "react";
+
+// src/features/game/adapters/inbound/createGameKeyboardEvent.ts
+function createGameKeyboardEvent(input) {
+  const binding = input.bindings.find((candidate) => candidate.key === input.key);
+  if (binding === undefined)
+    return;
+  const entityId = binding.entityId ?? input.fallbackEntityId;
+  return {
+    event: {
+      type: binding.eventType ?? input.fallbackEventType,
+      ...entityId === undefined ? {} : { entityId },
+      payload: { key: input.key }
+    },
+    preventDefault: binding.preventDefault ?? false
+  };
+}
+
+// src/features/game/adapters/inbound/createGamePointerEvent.ts
+function createGamePointerEvent(input) {
+  if (!Number.isFinite(input.measuredWidth) || !Number.isFinite(input.measuredHeight) || input.measuredWidth <= 0 || input.measuredHeight <= 0) {
+    return;
+  }
+  const localX = clampGamePercentage(input.localX / input.measuredWidth * 100);
+  const localY = clampGamePercentage(input.localY / input.measuredHeight * 100);
+  const x = clampGamePercentage(input.zoneX + localX * input.zoneWidth / 100);
+  const y = clampGamePercentage(input.zoneY + localY * input.zoneHeight / 100);
+  return {
+    type: input.eventType,
+    ...input.entityId === undefined ? {} : { entityId: input.entityId },
+    payload: { x, y }
+  };
+}
+
+// src/features/game/adapters/inbound/useGameInputZoneResponder.ts
+function useGameInputZoneResponder(props) {
+  const runtime = React11.useContext(GameRuntimeContext);
+  if (runtime === null)
+    throw new Error("GameInputZone must be rendered inside Game.");
+  const measuredSizeRef = React11.useRef({ width: 0, height: 0 });
+  const handleLayout = React11.useCallback((event) => {
+    const { width, height } = event.nativeEvent.layout;
+    measuredSizeRef.current = { width, height };
+  }, []);
+  const dispatchPointer = React11.useCallback((event) => {
+    if (runtime.interactionPolicy === "passive" || props.interactionPolicy === "passive")
+      return;
+    const measured = measuredSizeRef.current;
+    const gameEvent = createGamePointerEvent({
+      eventType: props.eventType,
+      ...props.entityId === undefined ? {} : { entityId: props.entityId },
+      localX: event.nativeEvent.locationX,
+      localY: event.nativeEvent.locationY,
+      measuredWidth: measured.width,
+      measuredHeight: measured.height,
+      zoneX: props.x ?? 0,
+      zoneY: props.y ?? 0,
+      zoneWidth: props.width ?? 100,
+      zoneHeight: props.height ?? 100
+    });
+    if (gameEvent !== undefined)
+      runtime.dispatch(gameEvent);
+  }, [
+    props.entityId,
+    props.eventType,
+    props.height,
+    props.interactionPolicy,
+    props.width,
+    props.x,
+    props.y,
+    runtime
+  ]);
+  const dispatchKeyboard = React11.useCallback((event) => {
+    if (runtime.interactionPolicy === "passive" || props.interactionPolicy === "passive")
+      return;
+    const result = createGameKeyboardEvent({
+      bindings: props.keyboardBindings ?? [],
+      fallbackEventType: props.eventType,
+      ...props.entityId === undefined ? {} : { fallbackEntityId: props.entityId },
+      key: event.key
+    });
+    if (result === undefined)
+      return;
+    if (result.preventDefault)
+      event.preventDefault();
+    runtime.dispatch(result.event);
+  }, [props.entityId, props.eventType, props.interactionPolicy, props.keyboardBindings, runtime]);
+  return {
+    dispatchKeyboard,
+    dispatchPointer,
+    handleLayout,
+    shouldSetResponder: () => (props.enabled ?? true) && props.interactionPolicy !== "passive" && runtime.interactionPolicy !== "passive"
+  };
+}
+
+// src/features/game/adapters/inbound/GameInputZone.tsx
+import { jsx as jsx5 } from "react/jsx-runtime";
+function GameInputZone2({
+  x = 0,
+  y = 0,
+  width = 100,
+  height = 100,
+  zIndex = 0,
+  enabled = true,
+  continuous = true,
+  keyboardBindings,
+  accessibilityLabel,
+  interactionPolicy,
+  testID,
+  ...inputProps
+}) {
+  const { dispatchKeyboard, dispatchPointer, handleLayout, shouldSetResponder } = useGameInputZoneResponder({
+    ...inputProps,
+    x,
+    y,
+    width,
+    height,
+    enabled: enabled && interactionPolicy !== "passive",
+    interactionPolicy,
+    continuous,
+    ...keyboardBindings === undefined ? {} : { keyboardBindings }
+  });
+  const keyboardProps = createGameInputZoneKeyboardProps({
+    dispatchKeyboard,
+    enabled: enabled && interactionPolicy !== "passive",
+    keyboardBindings
+  });
+  return /* @__PURE__ */ jsx5(import_react_native7.View, {
+    ...keyboardProps,
+    ...accessibilityLabel === undefined ? {} : { accessibilityLabel },
+    ...testID === undefined ? {} : { testID },
+    ...continuous ? { onResponderGrant: dispatchPointer, onResponderMove: dispatchPointer } : { onResponderRelease: dispatchPointer },
+    collapsable: false,
+    onLayout: handleLayout,
+    onStartShouldSetResponder: shouldSetResponder,
+    pointerEvents: enabled && interactionPolicy !== "passive" ? "auto" : "none",
+    style: createInputZoneStyle({ x, y, width, height, zIndex })
+  });
+}
+function createGameInputZoneKeyboardProps({
+  dispatchKeyboard,
+  enabled,
+  keyboardBindings
+}) {
+  if (import_react_native7.Platform.OS !== "web" || !enabled || keyboardBindings === undefined)
+    return {};
+  if (keyboardBindings.length === 0)
+    return {};
+  return { onKeyDown: dispatchKeyboard, tabIndex: 0 };
+}
+function createInputZoneStyle({ x, y, width, height, zIndex }) {
+  return {
+    left: toGamePercentage(x),
+    top: toGamePercentage(y),
+    width: toGamePercentage(width),
+    height: toGamePercentage(height),
+    zIndex,
+    ...styles3.root
+  };
+}
+var styles3 = import_react_native7.StyleSheet.create({
+  root: {
+    position: "absolute"
+  }
+});
+
+// src/features/game/adapters/inbound/GameMeasurementProbe.tsx
+import React12 from "react";
+
+// src/features/game/adapters/inbound/createGameMeasurementEvent.ts
+function createGameMeasurementEvent(input) {
+  return {
+    type: input.eventType,
+    entityId: input.entityId ?? input.sourceId,
+    payload: {
+      sourceId: input.sourceId,
+      targetId: input.targetId,
+      source: toGameMeasurementRecord(input.source),
+      target: toGameMeasurementRecord(input.target)
+    }
+  };
+}
+function toGameMeasurementRecord(bounds) {
+  return {
+    left: bounds.left,
+    right: bounds.right,
+    top: bounds.top,
+    bottom: bounds.bottom,
+    width: bounds.width,
+    height: bounds.height
+  };
+}
+
+// src/features/game/adapters/inbound/GameMeasurementProbe.tsx
+function GameMeasurementProbe2({
+  sourceId,
+  targetId,
+  eventType = "game.measurement",
+  entityId,
+  delayMs = 0,
+  enabled = true,
+  interactionPolicy
+}) {
+  const runtime = React12.useContext(GameRuntimeContext);
+  if (runtime === null)
+    throw new Error("GameMeasurementProbe must be rendered inside Game.");
+  React12.useEffect(() => {
+    if (!enabled || interactionPolicy === "passive" || runtime.interactionPolicy === "passive")
+      return;
+    const timer = setTimeout(() => {
+      dispatchGameMeasurement({
+        dispatch: runtime.dispatch,
+        measure: runtime.measure,
+        sourceId,
+        targetId,
+        eventType,
+        ...entityId === undefined ? {} : { entityId }
+      });
+    }, Math.max(0, delayMs));
+    return () => clearTimeout(timer);
+  }, [
+    delayMs,
+    enabled,
+    interactionPolicy,
+    entityId,
+    eventType,
+    runtime.dispatch,
+    runtime.interactionPolicy,
+    runtime.measure,
+    sourceId,
+    targetId
+  ]);
+  return null;
+}
+async function dispatchGameMeasurement(input) {
+  const [source, target] = await Promise.all([
+    input.measure(input.sourceId),
+    input.measure(input.targetId)
+  ]);
+  if (source === undefined || target === undefined)
+    return;
+  input.dispatch(createGameMeasurementEvent({
+    eventType: input.eventType,
+    ...input.entityId === undefined ? {} : { entityId: input.entityId },
+    sourceId: input.sourceId,
+    targetId: input.targetId,
+    source,
+    target
+  }));
+}
+
+// src/features/game/adapters/inbound/GameOverlay.tsx
+var import_react_native8 = __toESM(require_cjs(), 1);
+import { jsx as jsx6 } from "react/jsx-runtime";
+function GameOverlay2({
+  children,
+  placement = "fill",
+  blocking = false,
+  padding = 0,
+  accessibilityLabel,
+  interactionPolicy,
+  testID
+}) {
+  return /* @__PURE__ */ jsx6(View2, {
+    ...accessibilityLabel === undefined ? {} : { accessibilityLabel },
+    ...testID === undefined ? {} : { testID },
+    pointerEvents: interactionPolicy === "passive" ? "none" : blocking ? "auto" : "box-none",
+    style: [styles4.root, resolvePlacementStyle(placement), { padding }],
+    children
+  });
+}
+function resolvePlacementStyle(placement) {
+  switch (placement) {
+    case "center":
+      return { alignItems: "center", justifyContent: "center" };
+    case "top":
+      return { alignItems: "center", justifyContent: "flex-start" };
+    case "bottom":
+      return { alignItems: "center", justifyContent: "flex-end" };
+    case "top-left":
+      return { alignItems: "flex-start", justifyContent: "flex-start" };
+    case "top-right":
+      return { alignItems: "flex-end", justifyContent: "flex-start" };
+    case "bottom-left":
+      return { alignItems: "flex-start", justifyContent: "flex-end" };
+    case "bottom-right":
+      return { alignItems: "flex-end", justifyContent: "flex-end" };
+    case "fill":
+      return {};
+  }
+}
+var styles4 = import_react_native8.StyleSheet.create({
+  root: {
+    bottom: 0,
+    left: 0,
+    position: "absolute",
+    right: 0,
+    top: 0
+  }
+});
+export { GameField2, Game2, GameEntity2, GameInputZone2, GameMeasurementProbe2, GameOverlay2 };