npm - miaoda-game-devkit - Versions diffs - 0.7.1 → 0.7.3 - Mend

miaoda-game-devkit 0.7.1 → 0.7.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/mechanics/game-mechanics-capabilities.json +3367 -0
package/mechanics/game-mechanics-capabilities.schema.json +154 -0
package/mechanics/pnpmfile.cjs +473 -0
package/package.json +3 -1

package/mechanics/game-mechanics-capabilities.json ADDED Viewed

@@ -0,0 +1,3367 @@
+{
+  "$schema": "./game-mechanics-capabilities.schema.json",
+  "schemaVersion": 1,
+  "requiredPackages": [
+    "miaoda-game-arcade-motion-core",
+    "miaoda-game-adventure-interaction-cocos",
+    "miaoda-game-adventure-interaction-core",
+    "miaoda-game-adventure-interaction-phaser",
+    "miaoda-game-adventure-interaction-react",
+    "miaoda-game-adventure-scenario-bridge-core",
+    "miaoda-game-command-cocos",
+    "miaoda-game-command-core",
+    "miaoda-game-command-phaser",
+    "miaoda-game-command-react",
+    "miaoda-game-contact2d-core",
+    "miaoda-game-controls-phaser",
+    "miaoda-game-expression-core",
+    "miaoda-game-fighter-cocos",
+    "miaoda-game-fighter-core",
+    "miaoda-game-fixed-step-core",
+    "miaoda-game-grid-core",
+    "miaoda-game-investigation-core",
+    "miaoda-game-kinematic2d-core",
+    "miaoda-game-objective-core",
+    "miaoda-game-objective-phaser",
+    "miaoda-game-objective-react",
+    "miaoda-game-platformer-core",
+    "miaoda-game-platformer-kinematic-core",
+    "miaoda-game-quest-core",
+    "miaoda-game-quest-react",
+    "miaoda-game-save-core",
+    "miaoda-game-save-react",
+    "miaoda-game-scenario-cocos",
+    "miaoda-game-scenario-core",
+    "miaoda-game-scenario-phaser",
+    "miaoda-game-scenario-react",
+    "miaoda-game-scheduler-core",
+    "miaoda-game-sokoban-core",
+    "miaoda-game-topdown-vehicle-core",
+    "miaoda-game-mcr-mahjong-analysis-core",
+    "miaoda-game-mcr-mahjong-react",
+    "miaoda-game-mcr-mahjong-rules",
+    "miaoda-game-mcr-mahjong-session-core",
+    "miaoda-game-mcr-mahjong-strategy-core",
+    "miaoda-game-big-two-rules",
+    "miaoda-game-big-two-react",
+    "miaoda-game-blackjack-rules",
+    "miaoda-game-blackjack-react",
+    "miaoda-game-bridge-rules",
+    "miaoda-game-bridge-react",
+    "miaoda-game-canasta-rules",
+    "miaoda-game-canasta-react",
+    "miaoda-game-crazy-eights-rules",
+    "miaoda-game-crazy-eights-react",
+    "miaoda-game-dou-dizhu-rules",
+    "miaoda-game-dou-dizhu-react",
+    "miaoda-game-euchre-rules",
+    "miaoda-game-euchre-react",
+    "miaoda-game-gin-rummy-rules",
+    "miaoda-game-gin-rummy-react",
+    "miaoda-game-gong-zhu-rules",
+    "miaoda-game-gong-zhu-react",
+    "miaoda-game-gou-ji-rules",
+    "miaoda-game-gou-ji-react",
+    "miaoda-game-guandan-rules",
+    "miaoda-game-guandan-react",
+    "miaoda-game-hearts-rules",
+    "miaoda-game-hearts-react",
+    "miaoda-game-paodekuai-rules",
+    "miaoda-game-paodekuai-react",
+    "miaoda-game-spades-rules",
+    "miaoda-game-spades-react",
+    "miaoda-game-texas-holdem-rules",
+    "miaoda-game-texas-holdem-react",
+    "miaoda-game-thirteen-water-rules",
+    "miaoda-game-thirteen-water-react",
+    "miaoda-game-tractor-rules",
+    "miaoda-game-tractor-react",
+    "miaoda-game-zha-jinhua-rules",
+    "miaoda-game-zha-jinhua-react",
+    "miaoda-game-bridge-strategy-core",
+    "miaoda-game-canasta-analysis-core",
+    "miaoda-game-gou-ji-analysis-core",
+    "miaoda-game-guandan-analysis-core",
+    "miaoda-game-thirteen-water-analysis-core",
+    "miaoda-game-bridge-tournament-core",
+    "miaoda-game-bridge-tournament-react",
+    "miaoda-game-meld-core",
+    "miaoda-game-trick-taking-core",
+    "miaoda-game-deck-core",
+    "miaoda-game-deck-cocos",
+    "miaoda-game-deck-phaser",
+    "miaoda-game-deck-react",
+    "miaoda-game-deckbuilder-core",
+    "miaoda-game-draft-pool-core",
+    "miaoda-game-draft-pool-react",
+    "miaoda-game-grid-cocos",
+    "miaoda-game-grid-phaser",
+    "miaoda-game-grid-react",
+    "miaoda-game-grid-piece-core",
+    "miaoda-game-grid-piece-react",
+    "miaoda-game-turn-core",
+    "miaoda-game-turn-cocos",
+    "miaoda-game-turn-phaser",
+    "miaoda-game-turn-react",
+    "miaoda-game-sports-ball-core",
+    "miaoda-game-road-core",
+    "miaoda-game-road-cocos",
+    "miaoda-game-road-phaser",
+    "miaoda-game-pinball-core",
+    "miaoda-game-pinball-cocos",
+    "miaoda-game-pinball-phaser",
+    "miaoda-game-score-core",
+    "miaoda-game-score-phaser",
+    "miaoda-game-score-react",
+    "miaoda-game-roster-core",
+    "miaoda-game-roster-react",
+    "miaoda-game-ballistics-core",
+    "miaoda-game-mode7-core",
+    "miaoda-game-tractor-analysis-core"
+  ],
+  "packages": {
+    "miaoda-game-arcade-motion-core": {
+      "engine": "neutral",
+      "domains": ["input", "motion", "racing"],
+      "owns": ["forward-advance-motion", "lateral-steering-motion"],
+      "doesNotOwn": ["collision", "rendering", "input-device-mapping"],
+      "compatibleWith": [],
+      "useInsteadWhen": [],
+      "persistence": "none",
+      "testability": {
+        "observation": "snapshot",
+        "advance": "update",
+        "methods": { "observe": "snapshot()", "advance": "update(dt, input, curve?)" }
+      }
+    },
+    "miaoda-game-adventure-interaction-cocos": {
+      "engine": "cocos",
+      "domains": ["adventure", "narrative"],
+      "owns": ["cocos-adventure-lifecycle", "cocos-adventure-projection"],
+      "doesNotOwn": ["adventure-rules", "dialogue-flow", "rendering-assets"],
+      "compatibleWith": ["miaoda-game-adventure-interaction-core"],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-adventure-interaction-core",
+          "condition": "The host does not use Cocos Creator."
+        }
+      ],
+      "persistence": "delegated"
+    },
+    "miaoda-game-adventure-interaction-core": {
+      "engine": "neutral",
+      "domains": ["adventure", "narrative"],
+      "owns": [
+        "adventure-action-legality",
+        "adventure-state-transitions",
+        "adventure-content-analysis",
+        "adventure-goal-path-witnesses",
+        "adventure-goal-assertions",
+        "adventure-goal-path-contracts",
+        "adventure-softlock-analysis",
+        "adventure-validation-manifests",
+        "adventure-ending-analysis"
+      ],
+      "doesNotOwn": ["dialogue-flow", "quest-progress", "rendering"],
+      "compatibleWith": [
+        "miaoda-game-adventure-interaction-cocos",
+        "miaoda-game-adventure-interaction-phaser",
+        "miaoda-game-adventure-interaction-react",
+        "miaoda-game-adventure-scenario-bridge-core",
+        "miaoda-game-investigation-core"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-scenario-core",
+          "condition": "The content is primarily linear or branching dialogue rather than world verb/target interactions."
+        }
+      ],
+      "persistence": "snapshot",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "command",
+        "methods": {
+          "observe": "snapshot(), dispatch(...), combine(...) results",
+          "advance": "dispatch(request), combine(a, b)"
+        }
+      }
+    },
+    "miaoda-game-adventure-interaction-phaser": {
+      "engine": "phaser",
+      "domains": ["adventure", "narrative"],
+      "owns": ["phaser-adventure-lifecycle", "phaser-adventure-projection"],
+      "doesNotOwn": ["adventure-rules", "dialogue-flow", "rendering-assets"],
+      "compatibleWith": ["miaoda-game-adventure-interaction-core"],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-adventure-interaction-core",
+          "condition": "The host does not use Phaser."
+        }
+      ],
+      "persistence": "delegated"
+    },
+    "miaoda-game-adventure-interaction-react": {
+      "engine": "react",
+      "domains": ["adventure", "narrative"],
+      "owns": ["react-adventure-controller", "react-adventure-projection"],
+      "doesNotOwn": ["adventure-rules", "dialogue-flow", "dom-layout"],
+      "compatibleWith": ["miaoda-game-adventure-interaction-core"],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-adventure-interaction-core",
+          "condition": "The host does not need React subscriptions or controller projection."
+        }
+      ],
+      "persistence": "delegated"
+    },
+    "miaoda-game-adventure-scenario-bridge-core": {
+      "engine": "neutral",
+      "domains": ["adventure", "narrative"],
+      "owns": ["adventure-scenario-command-binding", "cross-content-binding-analysis"],
+      "doesNotOwn": ["adventure-state", "scenario-flow", "command-execution"],
+      "compatibleWith": ["miaoda-game-adventure-interaction-core", "miaoda-game-scenario-core"],
+      "useInsteadWhen": [],
+      "persistence": "none"
+    },
+    "miaoda-game-command-cocos": {
+      "engine": "cocos",
+      "domains": ["command", "narrative"],
+      "owns": ["cocos-command-lifecycle"],
+      "doesNotOwn": ["command-semantics", "scenario-flow", "rendering"],
+      "compatibleWith": ["miaoda-game-command-core"],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-command-core",
+          "condition": "The host does not use Cocos Creator."
+        }
+      ],
+      "persistence": "delegated"
+    },
+    "miaoda-game-command-core": {
+      "engine": "neutral",
+      "domains": ["command", "orchestration"],
+      "owns": ["atomic-command-application", "command-preview", "command-replay"],
+      "doesNotOwn": ["dialogue-authoring", "input-dispatch", "domain-rules"],
+      "compatibleWith": [
+        "miaoda-game-command-cocos",
+        "miaoda-game-command-phaser",
+        "miaoda-game-command-react"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-scenario-core",
+          "condition": "The requirement is authored branching story flow rather than atomic cross-system commands."
+        }
+      ],
+      "persistence": "snapshot",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "command",
+        "methods": {
+          "observe": "state(), dispatch(...) result",
+          "advance": "dispatch(command, options?)"
+        }
+      }
+    },
+    "miaoda-game-command-phaser": {
+      "engine": "phaser",
+      "domains": ["command", "orchestration"],
+      "owns": ["phaser-command-lifecycle"],
+      "doesNotOwn": ["command-semantics", "scenario-flow", "rendering"],
+      "compatibleWith": ["miaoda-game-command-core"],
+      "useInsteadWhen": [
+        { "package": "miaoda-game-command-core", "condition": "The host does not use Phaser." }
+      ],
+      "persistence": "delegated"
+    },
+    "miaoda-game-command-react": {
+      "engine": "react",
+      "domains": ["command", "orchestration"],
+      "owns": ["react-command-controller", "react-command-projection"],
+      "doesNotOwn": ["command-semantics", "scenario-flow", "dom-layout"],
+      "compatibleWith": ["miaoda-game-command-core"],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-command-core",
+          "condition": "The host does not need React subscriptions or projected command views."
+        }
+      ],
+      "persistence": "delegated"
+    },
+    "miaoda-game-contact2d-core": {
+      "engine": "neutral",
+      "domains": ["collision", "geometry", "physics"],
+      "owns": [
+        "continuous-circle-time-of-impact",
+        "continuous-circle-capsule-contact",
+        "deterministic-contact-ordering"
+      ],
+      "doesNotOwn": [
+        "broadphase-indexing",
+        "collision-response",
+        "gameplay-rules",
+        "physics-world",
+        "position-integration"
+      ],
+      "compatibleWith": [
+        "miaoda-game-ballistics-core",
+        "miaoda-game-shooter-core",
+        "miaoda-game-sports-ball-core"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-targeting2d-core",
+          "condition": "The game needs current-frame area filtering or spatial indexing rather than time of impact."
+        },
+        {
+          "package": "miaoda-game-kinematic2d-core",
+          "condition": "The game needs position-owning swept-AABB movement and collision response."
+        }
+      ],
+      "persistence": "none",
+      "testability": {
+        "observation": "return-value",
+        "advance": "none",
+        "methods": {
+          "observe": "sweepCircles(...), sweepCircleCapsule(...), sortContacts(...)",
+          "advance": "sweepCircles(...)"
+        }
+      }
+    },
+    "miaoda-game-controls-phaser": {
+      "engine": "phaser",
+      "domains": ["controls", "input", "joystick"],
+      "owns": ["logical-input-normalization", "device-input-lifecycle"],
+      "doesNotOwn": ["game-rules", "simulation-clock", "rendering"],
+      "compatibleWith": ["miaoda-game-fixed-step-core"],
+      "useInsteadWhen": [],
+      "persistence": "none",
+      "testability": {
+        "observation": "axis-and-actions",
+        "advance": "update",
+        "methods": { "observe": "axis(name), action(name)", "advance": "update()" }
+      }
+    },
+    "miaoda-game-expression-core": {
+      "engine": "neutral",
+      "domains": ["authoring", "narrative"],
+      "owns": ["pure-expression-compilation", "pure-expression-evaluation"],
+      "doesNotOwn": ["effects", "scenario-flow", "state-mutation"],
+      "compatibleWith": ["miaoda-game-scenario-core"],
+      "useInsteadWhen": [],
+      "persistence": "none"
+    },
+    "miaoda-game-fixed-step-core": {
+      "engine": "neutral",
+      "domains": ["input", "simulation", "time"],
+      "owns": ["fixed-tick-advancement", "logical-input-buffer", "logical-input-tape"],
+      "doesNotOwn": ["game-rules", "physics", "rendering", "wall-clock-scheduling"],
+      "compatibleWith": ["miaoda-game-controls-phaser"],
+      "useInsteadWhen": [],
+      "persistence": "none",
+      "testability": {
+        "observation": "snapshot-and-step-result",
+        "advance": "step",
+        "methods": { "observe": "snapshot", "advance": "step(count, callback)" }
+      }
+    },
+    "miaoda-game-grid-core": {
+      "engine": "neutral",
+      "domains": ["grid", "pathfinding", "search"],
+      "owns": ["grid-pathfinding", "grid-coordinate-model"],
+      "doesNotOwn": ["collision", "rendering", "unit-movement"],
+      "compatibleWith": [],
+      "useInsteadWhen": [],
+      "persistence": "none",
+      "testability": {
+        "observation": "return-value",
+        "advance": "none",
+        "methods": { "observe": "findPathResult(...)", "advance": "findPathResult(...)" }
+      }
+    },
+    "miaoda-game-fighter-core": {
+      "engine": "neutral",
+      "domains": ["combat", "fighting-game", "input"],
+      "owns": [
+        "fighter-input-normalization",
+        "fighter-command-parsing",
+        "fighter-control-states",
+        "fighter-action-orchestration",
+        "fighter-hitstop-control",
+        "fighter-versus-resolution",
+        "fighter-guard-policy",
+        "fighter-throw-policy",
+        "fighter-counter-punish-policy",
+        "fighter-air-combo-policy",
+        "fighter-resource-state",
+        "fighter-round-flow",
+        "fighter-arena-roster",
+        "fighter-arena-input-session",
+        "fighter-arena-team-identity",
+        "fighter-arena-stock-match",
+        "fighter-arena-time-score-match",
+        "fighter-arena-team-scoring",
+        "fighter-arena-sudden-death-state",
+        "fighter-arena-target-selection",
+        "fighter-arena-contact-arbitration",
+        "fighter-arena-friendly-fire-policy",
+        "fighter-arena-world-rollback",
+        "fighter-rollback-history",
+        "fighter-resimulation",
+        "fighter-state-checksums",
+        "fighter-session-determinism",
+        "fighter-snapshots"
+      ],
+      "doesNotOwn": [
+        "engine-input-events",
+        "animation-assets",
+        "movement-integration",
+        "hitbox-resolution",
+        "network-transport",
+        "rollback-session-authority"
+      ],
+      "compatibleWith": [
+        "miaoda-game-action-runtime-core",
+        "miaoda-game-combat2d-core",
+        "miaoda-game-fixed-step-core",
+        "miaoda-game-serialization-core",
+        "miaoda-game-stats-core",
+        "miaoda-game-status-core"
+      ],
+      "useInsteadWhen": [],
+      "persistence": "snapshot"
+    },
+    "miaoda-game-fighter-cocos": {
+      "engine": "cocos",
+      "domains": ["combat", "fighting-game", "presentation"],
+      "owns": ["fighter-semantic-presentation-bridge"],
+      "doesNotOwn": [
+        "fighter-rules",
+        "round-authority",
+        "animation-assets",
+        "audio-assets",
+        "effect-assets"
+      ],
+      "compatibleWith": ["miaoda-game-fighter-core", "miaoda-game-juice-cocos"],
+      "useInsteadWhen": [],
+      "persistence": "none"
+    },
+    "miaoda-game-investigation-core": {
+      "engine": "neutral",
+      "domains": ["adventure", "investigation", "narrative"],
+      "owns": [
+        "investigation-case-compilation",
+        "evidence-statement-rules",
+        "accusation-prerequisites"
+      ],
+      "doesNotOwn": ["adventure-execution", "dialogue-flow", "rendering"],
+      "compatibleWith": ["miaoda-game-adventure-interaction-core"],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-adventure-interaction-core",
+          "condition": "The game needs general world interactions without evidence, statements, or accusations."
+        }
+      ],
+      "persistence": "delegated"
+    },
+    "miaoda-game-kinematic2d-core": {
+      "engine": "neutral",
+      "domains": ["collision", "motion", "physics"],
+      "owns": ["swept-aabb-motion", "collision-response", "contact-resolution"],
+      "doesNotOwn": ["gravity", "gameplay-rules", "rendering", "input-device-mapping"],
+      "compatibleWith": ["miaoda-game-platformer-kinematic-core"],
+      "useInsteadWhen": [],
+      "persistence": "snapshot",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "step",
+        "methods": {
+          "observe": "snapshot",
+          "advance": "step(dtSeconds, requestedVelocity, world, options?)"
+        }
+      }
+    },
+    "miaoda-game-objective-core": {
+      "engine": "neutral",
+      "domains": ["objective", "progression"],
+      "owns": ["objective-progress", "objective-completion", "objective-persistence"],
+      "doesNotOwn": ["quest-stage-graphs", "dialogue-flow", "reward-granting"],
+      "compatibleWith": [
+        "miaoda-game-objective-phaser",
+        "miaoda-game-objective-react",
+        "miaoda-game-quest-core"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-quest-core",
+          "condition": "Progress belongs to prerequisite quests, stage graphs, exclusive branches, failure, or reward claims."
+        }
+      ],
+      "persistence": "snapshot",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "update",
+        "methods": {
+          "observe": "state(), snapshot",
+          "advance": "emit(event), tick(dtSeconds)"
+        }
+      }
+    },
+    "miaoda-game-objective-phaser": {
+      "engine": "phaser",
+      "domains": ["objective", "progression"],
+      "owns": ["phaser-objective-lifecycle"],
+      "doesNotOwn": ["objective-semantics", "quest-stage-graphs", "rendering-assets"],
+      "compatibleWith": ["miaoda-game-objective-core"],
+      "useInsteadWhen": [
+        { "package": "miaoda-game-objective-core", "condition": "The host does not use Phaser." }
+      ],
+      "persistence": "delegated"
+    },
+    "miaoda-game-objective-react": {
+      "engine": "react",
+      "domains": ["objective", "progression"],
+      "owns": ["react-objective-projection", "react-objective-subscription"],
+      "doesNotOwn": ["objective-semantics", "quest-stage-graphs", "dom-layout"],
+      "compatibleWith": ["miaoda-game-objective-core"],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-objective-core",
+          "condition": "The host does not need React subscriptions."
+        }
+      ],
+      "persistence": "delegated"
+    },
+    "miaoda-game-platformer-core": {
+      "engine": "neutral",
+      "domains": ["motion", "platformer"],
+      "owns": ["platformer-movement-feel", "platformer-velocity-rules"],
+      "doesNotOwn": [
+        "collision-resolution",
+        "position-integration",
+        "rendering",
+        "input-device-mapping"
+      ],
+      "compatibleWith": ["miaoda-game-platformer-kinematic-core"],
+      "useInsteadWhen": [],
+      "persistence": "none",
+      "testability": {
+        "observation": "step-result",
+        "advance": "step",
+        "methods": {
+          "observe": "step(dt, input, contacts)",
+          "advance": "step(dt, input, contacts)"
+        }
+      }
+    },
+    "miaoda-game-platformer-kinematic-core": {
+      "engine": "neutral",
+      "domains": ["collision", "motion", "platformer"],
+      "owns": ["platformer-kinematic-step", "platformer-placement-validation"],
+      "doesNotOwn": ["input-device-mapping", "rendering"],
+      "compatibleWith": ["miaoda-game-kinematic2d-core", "miaoda-game-platformer-core"],
+      "useInsteadWhen": [],
+      "persistence": "none",
+      "testability": {
+        "observation": "snapshot-and-step-result",
+        "advance": "step",
+        "methods": { "observe": "snapshot()", "advance": "step(dt, input, world)" }
+      }
+    },
+    "miaoda-game-quest-core": {
+      "engine": "neutral",
+      "domains": ["narrative", "progression", "quest"],
+      "owns": ["quest-stage-graphs", "quest-branches", "quest-reward-claims"],
+      "doesNotOwn": ["dialogue-decisions", "objective-algorithms", "reward-granting"],
+      "compatibleWith": ["miaoda-game-objective-core", "miaoda-game-quest-react"],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-objective-core",
+          "condition": "The requirement is one lightweight challenge or achievement without quest lifecycle."
+        },
+        {
+          "package": "miaoda-game-scenario-core",
+          "condition": "The requirement is transient branching dialogue rather than persistent quest progress."
+        }
+      ],
+      "persistence": "snapshot"
+    },
+    "miaoda-game-quest-react": {
+      "engine": "react",
+      "domains": ["narrative", "progression", "quest"],
+      "owns": ["react-quest-controller", "react-quest-projection"],
+      "doesNotOwn": ["quest-semantics", "dialogue-flow", "dom-layout"],
+      "compatibleWith": ["miaoda-game-quest-core"],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-quest-core",
+          "condition": "The host does not need React subscriptions or controller projection."
+        }
+      ],
+      "persistence": "delegated"
+    },
+    "miaoda-game-save-core": {
+      "engine": "neutral",
+      "domains": ["persistence"],
+      "owns": ["save-envelope-validation", "save-version-migration", "save-checksums"],
+      "doesNotOwn": ["storage-backends", "story-flow", "domain-state"],
+      "compatibleWith": ["miaoda-game-save-react"],
+      "useInsteadWhen": [],
+      "persistence": "envelope",
+      "testability": {
+        "observation": "return-value",
+        "advance": "none",
+        "methods": {
+          "observe": "save(state, metadata), load(envelope, state)",
+          "advance": "load(envelope, state)"
+        }
+      }
+    },
+    "miaoda-game-save-react": {
+      "engine": "react",
+      "domains": ["persistence"],
+      "owns": ["react-save-controller", "react-save-status"],
+      "doesNotOwn": ["storage-backends", "save-envelope-semantics", "dom-layout"],
+      "compatibleWith": ["miaoda-game-save-core"],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-save-core",
+          "condition": "The host does not need React save status and controller wiring."
+        }
+      ],
+      "persistence": "delegated"
+    },
+    "miaoda-game-scenario-cocos": {
+      "engine": "cocos",
+      "domains": ["dialogue", "narrative"],
+      "owns": ["cocos-scenario-lifecycle", "cocos-scenario-presenters"],
+      "doesNotOwn": ["scenario-semantics", "dialogue-layout", "storage-backends"],
+      "compatibleWith": ["miaoda-game-scenario-core"],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-scenario-core",
+          "condition": "The host does not use Cocos Creator."
+        }
+      ],
+      "persistence": "delegated"
+    },
+    "miaoda-game-scenario-core": {
+      "engine": "neutral",
+      "domains": ["dialogue", "narrative"],
+      "owns": ["branching-scenario-flow", "scenario-memory", "scenario-choice-checkpoints"],
+      "doesNotOwn": ["quest-progress", "world-interactions", "rendering"],
+      "compatibleWith": [
+        "miaoda-game-expression-core",
+        "miaoda-game-scenario-cocos",
+        "miaoda-game-scenario-phaser",
+        "miaoda-game-scenario-react"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-quest-core",
+          "condition": "The requirement is persistent quest stages, prerequisites, failure, or reward claims."
+        },
+        {
+          "package": "miaoda-game-adventure-interaction-core",
+          "condition": "The requirement is executable world verb/target/item/topic interactions."
+        }
+      ],
+      "persistence": "snapshot"
+    },
+    "miaoda-game-scenario-phaser": {
+      "engine": "phaser",
+      "domains": ["dialogue", "narrative"],
+      "owns": ["phaser-scenario-lifecycle", "phaser-scenario-presenters"],
+      "doesNotOwn": ["scenario-semantics", "dialogue-layout", "storage-backends"],
+      "compatibleWith": ["miaoda-game-scenario-core"],
+      "useInsteadWhen": [
+        { "package": "miaoda-game-scenario-core", "condition": "The host does not use Phaser." }
+      ],
+      "persistence": "delegated"
+    },
+    "miaoda-game-scenario-react": {
+      "engine": "react",
+      "domains": ["dialogue", "narrative"],
+      "owns": ["react-scenario-controller", "react-scenario-projection"],
+      "doesNotOwn": ["scenario-semantics", "dom-layout", "storage-backends"],
+      "compatibleWith": ["miaoda-game-scenario-core"],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-scenario-core",
+          "condition": "The host does not need React subscriptions or controller projection."
+        }
+      ],
+      "persistence": "delegated"
+    },
+    "miaoda-game-scheduler-core": {
+      "engine": "neutral",
+      "domains": ["scheduler", "simulation", "time"],
+      "owns": ["domain-time-scheduling", "scheduled-occurrence-ordering"],
+      "doesNotOwn": ["command-execution", "rendering", "wall-clock-timers"],
+      "compatibleWith": [],
+      "useInsteadWhen": [],
+      "persistence": "snapshot",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "scheduler",
+        "methods": { "observe": "snapshot", "advance": "advanceTo(target)" }
+      }
+    },
+    "miaoda-game-sokoban-core": {
+      "engine": "neutral",
+      "domains": ["puzzle", "rules", "search"],
+      "owns": ["sokoban-rule-application", "bounded-sokoban-solving"],
+      "doesNotOwn": ["input-device-mapping", "rendering", "clock"],
+      "compatibleWith": [],
+      "useInsteadWhen": [],
+      "persistence": "none",
+      "testability": {
+        "observation": "command-result",
+        "advance": "command",
+        "methods": { "observe": "applyMove(...)", "advance": "replayMoves(...)" }
+      }
+    },
+    "miaoda-game-topdown-vehicle-core": {
+      "engine": "neutral",
+      "domains": ["input", "motion", "vehicle"],
+      "owns": ["grip-drift-motion", "heading-steering", "topdown-vehicle-kinematics"],
+      "doesNotOwn": ["collision", "input-device-mapping", "rendering"],
+      "compatibleWith": [],
+      "useInsteadWhen": [],
+      "persistence": "none",
+      "testability": {
+        "observation": "snapshot",
+        "advance": "update",
+        "methods": { "observe": "snapshot()", "advance": "update(dt, input)" }
+      }
+    },
+    "miaoda-game-mcr-mahjong-analysis-core": {
+      "engine": "neutral",
+      "domains": [
+        "analysis",
+        "mahjong",
+        "tabletop"
+      ],
+      "owns": [
+        "mcr-hand-scoring",
+        "mcr-shanten-analysis",
+        "mcr-effective-tile-analysis",
+        "mcr-discard-advice"
+      ],
+      "doesNotOwn": [
+        "mcr-round-authority",
+        "mcr-legal-action-authority",
+        "mcr-bot-action-selection",
+        "mcr-session-deadlines",
+        "rendering"
+      ],
+      "compatibleWith": [
+        "miaoda-game-mcr-mahjong-react",
+        "miaoda-game-mcr-mahjong-rules",
+        "miaoda-game-mcr-mahjong-strategy-core"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-mcr-mahjong-strategy-core",
+          "condition": "The game needs an autonomous rules-ready bot action rather than player-facing analysis or discard advice."
+        }
+      ],
+      "persistence": "none",
+      "testability": {
+        "observation": "return-value",
+        "advance": "none",
+        "methods": {
+          "observe": "analyzeMcrHand(...), analyzeMcrHandProgress(...), settleMcrWin(...) results",
+          "advance": "analyzeMcrHand(...)"
+        }
+      }
+    },
+    "miaoda-game-mcr-mahjong-react": {
+      "engine": "react",
+      "domains": [
+        "mahjong",
+        "react",
+        "tabletop"
+      ],
+      "owns": [
+        "react-mcr-controller-lifecycle",
+        "react-mcr-safe-view-subscriptions"
+      ],
+      "doesNotOwn": [
+        "mcr-rules",
+        "mcr-bot-action-selection",
+        "mcr-session-deadlines",
+        "networking",
+        "dom-layout"
+      ],
+      "compatibleWith": [
+        "miaoda-game-mcr-mahjong-analysis-core",
+        "miaoda-game-mcr-mahjong-rules",
+        "miaoda-game-mcr-mahjong-strategy-core"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-mcr-mahjong-rules",
+          "condition": "The host does not need React controller ownership or safe-view subscriptions."
+        }
+      ],
+      "persistence": "delegated",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "command",
+        "methods": {
+          "observe": "controller.view, useMcrRoundView(controller), useMcrMatchView(controller)",
+          "advance": "controller.dispatch(action)"
+        }
+      }
+    },
+    "miaoda-game-mcr-mahjong-rules": {
+      "engine": "neutral",
+      "domains": [
+        "mahjong",
+        "rules",
+        "tabletop"
+      ],
+      "owns": [
+        "mcr-round-authority",
+        "mcr-match-authority",
+        "mcr-legal-action-authority",
+        "mcr-claim-resolution",
+        "mcr-settlement",
+        "mcr-safe-player-views",
+        "mcr-replay-restoration"
+      ],
+      "doesNotOwn": [
+        "mcr-bot-action-selection",
+        "mcr-session-deadlines",
+        "react-subscriptions",
+        "rendering",
+        "networking"
+      ],
+      "compatibleWith": [
+        "miaoda-game-mcr-mahjong-analysis-core",
+        "miaoda-game-mcr-mahjong-react",
+        "miaoda-game-mcr-mahjong-session-core",
+        "miaoda-game-mcr-mahjong-strategy-core"
+      ],
+      "useInsteadWhen": [],
+      "persistence": "snapshot",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "command",
+        "methods": {
+          "observe": "createMcrRoundPlayerView(state, playerId), restoreMcrRoundState(snapshot)",
+          "advance": "applyMcrRoundAction(state, action), applyMcrMatchAction(state, action)"
+        }
+      }
+    },
+    "miaoda-game-mcr-mahjong-session-core": {
+      "engine": "neutral",
+      "domains": [
+        "mahjong",
+        "orchestration",
+        "session",
+        "time"
+      ],
+      "owns": [
+        "mcr-session-deadlines",
+        "mcr-timeout-actions",
+        "mcr-idempotent-commands",
+        "mcr-revision-checks",
+        "mcr-reconnect-views"
+      ],
+      "doesNotOwn": [
+        "mcr-bot-action-selection",
+        "process-clock-selection",
+        "networking",
+        "authentication",
+        "storage-backends"
+      ],
+      "compatibleWith": [
+        "miaoda-game-mcr-mahjong-rules",
+        "miaoda-game-mcr-mahjong-strategy-core"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-mcr-mahjong-rules",
+          "condition": "A local host needs only direct deterministic rule transitions without deadlines, idempotency, or reconnect state."
+        }
+      ],
+      "persistence": "snapshot",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "manual",
+        "methods": {
+          "observe": "createMcrSessionPlayerView(state, playerId), validateMcrSessionState(snapshot)",
+          "advance": "submitMcrSessionCommand(state, command, nowMs), advanceMcrSession(state, nowMs, options)"
+        }
+      }
+    },
+    "miaoda-game-mcr-mahjong-strategy-core": {
+      "engine": "neutral",
+      "domains": [
+        "ai",
+        "mahjong",
+        "strategy"
+      ],
+      "owns": [
+        "mcr-bot-action-selection",
+        "mcr-bot-difficulty-policy",
+        "mcr-bot-deterministic-tiebreaking"
+      ],
+      "doesNotOwn": [
+        "mcr-round-authority",
+        "mcr-action-scheduling",
+        "mcr-session-deadlines",
+        "hidden-opponent-state",
+        "rendering"
+      ],
+      "compatibleWith": [
+        "miaoda-game-mcr-mahjong-analysis-core",
+        "miaoda-game-mcr-mahjong-react",
+        "miaoda-game-mcr-mahjong-rules",
+        "miaoda-game-mcr-mahjong-session-core"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-mcr-mahjong-analysis-core",
+          "condition": "The product needs player-facing scoring, shanten, or discard advice but no autonomous bot action."
+        }
+      ],
+      "persistence": "none",
+      "testability": {
+        "observation": "return-value",
+        "advance": "none",
+        "methods": {
+          "observe": "chooseMcrBotDecision(view, options), chooseMcrBotAction(view, options)",
+          "advance": "chooseMcrBotAction(view, options)"
+        }
+      }
+    },
+    "miaoda-game-big-two-rules": {
+      "engine": "neutral",
+      "domains": [
+        "card-game",
+        "rules",
+        "tabletop"
+      ],
+      "owns": [
+        "big-two-authoritative-rules",
+        "big-two-legal-action-authority",
+        "big-two-safe-player-views",
+        "big-two-snapshot-validation"
+      ],
+      "doesNotOwn": [
+        "big-two-bot-action-selection",
+        "session-deadlines",
+        "networking",
+        "rendering"
+      ],
+      "compatibleWith": [
+        "miaoda-game-big-two-react"
+      ],
+      "useInsteadWhen": [],
+      "persistence": "snapshot",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "command",
+        "methods": {
+          "observe": "createBigTwoPlayerView(state, playerId)",
+          "advance": "applyBigTwoAction(state, action)"
+        }
+      }
+    },
+    "miaoda-game-big-two-react": {
+      "engine": "react",
+      "domains": [
+        "card-game",
+        "react",
+        "tabletop"
+      ],
+      "owns": [
+        "react-big-two-controller-lifecycle",
+        "react-big-two-safe-view-subscriptions",
+        "react-big-two-commit-projection"
+      ],
+      "doesNotOwn": [
+        "big-two-authoritative-rules",
+        "big-two-bot-action-selection",
+        "session-deadlines",
+        "networking",
+        "dom-layout"
+      ],
+      "compatibleWith": [
+        "miaoda-game-big-two-rules"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-big-two-rules",
+          "condition": "The host does not need React controller ownership or safe-view subscriptions."
+        }
+      ],
+      "persistence": "delegated",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "command",
+        "methods": {
+          "observe": "controller.view, useBigTwoView(controller)",
+          "advance": "controller.dispatch(action)"
+        }
+      }
+    },
+    "miaoda-game-blackjack-rules": {
+      "engine": "neutral",
+      "domains": [
+        "card-game",
+        "rules",
+        "tabletop"
+      ],
+      "owns": [
+        "blackjack-authoritative-rules",
+        "blackjack-legal-action-authority",
+        "blackjack-safe-player-views",
+        "blackjack-snapshot-validation"
+      ],
+      "doesNotOwn": [
+        "blackjack-bot-action-selection",
+        "session-deadlines",
+        "networking",
+        "rendering"
+      ],
+      "compatibleWith": [
+        "miaoda-game-blackjack-react"
+      ],
+      "useInsteadWhen": [],
+      "persistence": "snapshot",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "command",
+        "methods": {
+          "observe": "createBlackjackPlayerView(state, playerId)",
+          "advance": "applyBlackjackAction(state, action)"
+        }
+      }
+    },
+    "miaoda-game-blackjack-react": {
+      "engine": "react",
+      "domains": [
+        "card-game",
+        "react",
+        "tabletop"
+      ],
+      "owns": [
+        "react-blackjack-controller-lifecycle",
+        "react-blackjack-safe-view-subscriptions",
+        "react-blackjack-commit-projection"
+      ],
+      "doesNotOwn": [
+        "blackjack-authoritative-rules",
+        "blackjack-bot-action-selection",
+        "session-deadlines",
+        "networking",
+        "dom-layout"
+      ],
+      "compatibleWith": [
+        "miaoda-game-blackjack-rules"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-blackjack-rules",
+          "condition": "The host does not need React controller ownership or safe-view subscriptions."
+        }
+      ],
+      "persistence": "delegated",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "command",
+        "methods": {
+          "observe": "controller.view, useBlackjackView(controller)",
+          "advance": "controller.dispatch(action)"
+        }
+      }
+    },
+    "miaoda-game-bridge-rules": {
+      "engine": "neutral",
+      "domains": [
+        "card-game",
+        "rules",
+        "tabletop"
+      ],
+      "owns": [
+        "bridge-authoritative-rules",
+        "bridge-legal-action-authority",
+        "bridge-safe-player-views",
+        "bridge-snapshot-validation"
+      ],
+      "doesNotOwn": [
+        "bridge-bot-action-selection",
+        "session-deadlines",
+        "networking",
+        "rendering"
+      ],
+      "compatibleWith": [
+        "miaoda-game-bridge-react",
+        "miaoda-game-bridge-strategy-core"
+      ],
+      "useInsteadWhen": [],
+      "persistence": "snapshot",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "command",
+        "methods": {
+          "observe": "createBridgePlayerView(state, playerId)",
+          "advance": "applyBridgeAction(state, action)"
+        }
+      }
+    },
+    "miaoda-game-bridge-react": {
+      "engine": "react",
+      "domains": [
+        "card-game",
+        "react",
+        "tabletop"
+      ],
+      "owns": [
+        "react-bridge-controller-lifecycle",
+        "react-bridge-safe-view-subscriptions",
+        "react-bridge-commit-projection"
+      ],
+      "doesNotOwn": [
+        "bridge-authoritative-rules",
+        "bridge-bot-action-selection",
+        "session-deadlines",
+        "networking",
+        "dom-layout"
+      ],
+      "compatibleWith": [
+        "miaoda-game-bridge-rules",
+        "miaoda-game-bridge-strategy-core"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-bridge-rules",
+          "condition": "The host does not need React controller ownership or safe-view subscriptions."
+        }
+      ],
+      "persistence": "delegated",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "command",
+        "methods": {
+          "observe": "controller.view, useBridgeView(controller)",
+          "advance": "controller.dispatch(action)"
+        }
+      }
+    },
+    "miaoda-game-canasta-rules": {
+      "engine": "neutral",
+      "domains": [
+        "card-game",
+        "rules",
+        "tabletop"
+      ],
+      "owns": [
+        "canasta-authoritative-rules",
+        "canasta-legal-action-authority",
+        "canasta-safe-player-views",
+        "canasta-snapshot-validation"
+      ],
+      "doesNotOwn": [
+        "canasta-bot-action-selection",
+        "session-deadlines",
+        "networking",
+        "rendering"
+      ],
+      "compatibleWith": [
+        "miaoda-game-canasta-react",
+        "miaoda-game-canasta-analysis-core"
+      ],
+      "useInsteadWhen": [],
+      "persistence": "snapshot",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "command",
+        "methods": {
+          "observe": "createCanastaPlayerView(state, playerId)",
+          "advance": "applyCanastaAction(state, action)"
+        }
+      }
+    },
+    "miaoda-game-canasta-react": {
+      "engine": "react",
+      "domains": [
+        "card-game",
+        "react",
+        "tabletop"
+      ],
+      "owns": [
+        "react-canasta-controller-lifecycle",
+        "react-canasta-safe-view-subscriptions",
+        "react-canasta-commit-projection"
+      ],
+      "doesNotOwn": [
+        "canasta-authoritative-rules",
+        "canasta-bot-action-selection",
+        "session-deadlines",
+        "networking",
+        "dom-layout"
+      ],
+      "compatibleWith": [
+        "miaoda-game-canasta-rules",
+        "miaoda-game-canasta-analysis-core"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-canasta-rules",
+          "condition": "The host does not need React controller ownership or safe-view subscriptions."
+        }
+      ],
+      "persistence": "delegated",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "command",
+        "methods": {
+          "observe": "controller.view, useCanastaView(controller)",
+          "advance": "controller.dispatch(action)"
+        }
+      }
+    },
+    "miaoda-game-crazy-eights-rules": {
+      "engine": "neutral",
+      "domains": [
+        "card-game",
+        "rules",
+        "tabletop"
+      ],
+      "owns": [
+        "crazy-eights-authoritative-rules",
+        "crazy-eights-legal-action-authority",
+        "crazy-eights-safe-player-views",
+        "crazy-eights-snapshot-validation"
+      ],
+      "doesNotOwn": [
+        "crazy-eights-bot-action-selection",
+        "session-deadlines",
+        "networking",
+        "rendering"
+      ],
+      "compatibleWith": [
+        "miaoda-game-crazy-eights-react"
+      ],
+      "useInsteadWhen": [],
+      "persistence": "snapshot",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "command",
+        "methods": {
+          "observe": "createCrazyEightsPlayerView(state, playerId)",
+          "advance": "applyCrazyEightsAction(state, action)"
+        }
+      }
+    },
+    "miaoda-game-crazy-eights-react": {
+      "engine": "react",
+      "domains": [
+        "card-game",
+        "react",
+        "tabletop"
+      ],
+      "owns": [
+        "react-crazy-eights-controller-lifecycle",
+        "react-crazy-eights-safe-view-subscriptions",
+        "react-crazy-eights-commit-projection"
+      ],
+      "doesNotOwn": [
+        "crazy-eights-authoritative-rules",
+        "crazy-eights-bot-action-selection",
+        "session-deadlines",
+        "networking",
+        "dom-layout"
+      ],
+      "compatibleWith": [
+        "miaoda-game-crazy-eights-rules"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-crazy-eights-rules",
+          "condition": "The host does not need React controller ownership or safe-view subscriptions."
+        }
+      ],
+      "persistence": "delegated",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "command",
+        "methods": {
+          "observe": "controller.view, useCrazyEightsView(controller)",
+          "advance": "controller.dispatch(action)"
+        }
+      }
+    },
+    "miaoda-game-dou-dizhu-rules": {
+      "engine": "neutral",
+      "domains": [
+        "card-game",
+        "rules",
+        "tabletop"
+      ],
+      "owns": [
+        "dou-dizhu-authoritative-rules",
+        "dou-dizhu-legal-action-authority",
+        "dou-dizhu-safe-player-views",
+        "dou-dizhu-snapshot-validation"
+      ],
+      "doesNotOwn": [
+        "dou-dizhu-bot-action-selection",
+        "session-deadlines",
+        "networking",
+        "rendering"
+      ],
+      "compatibleWith": [
+        "miaoda-game-dou-dizhu-react"
+      ],
+      "useInsteadWhen": [],
+      "persistence": "snapshot",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "command",
+        "methods": {
+          "observe": "createDouDizhuPlayerView(state, playerId)",
+          "advance": "applyDouDizhuAction(state, action)"
+        }
+      }
+    },
+    "miaoda-game-dou-dizhu-react": {
+      "engine": "react",
+      "domains": [
+        "card-game",
+        "react",
+        "tabletop"
+      ],
+      "owns": [
+        "react-dou-dizhu-controller-lifecycle",
+        "react-dou-dizhu-safe-view-subscriptions",
+        "react-dou-dizhu-commit-projection"
+      ],
+      "doesNotOwn": [
+        "dou-dizhu-authoritative-rules",
+        "dou-dizhu-bot-action-selection",
+        "session-deadlines",
+        "networking",
+        "dom-layout"
+      ],
+      "compatibleWith": [
+        "miaoda-game-dou-dizhu-rules"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-dou-dizhu-rules",
+          "condition": "The host does not need React controller ownership or safe-view subscriptions."
+        }
+      ],
+      "persistence": "delegated",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "command",
+        "methods": {
+          "observe": "controller.view, useDouDizhuView(controller)",
+          "advance": "controller.dispatch(action)"
+        }
+      }
+    },
+    "miaoda-game-euchre-rules": {
+      "engine": "neutral",
+      "domains": [
+        "card-game",
+        "rules",
+        "tabletop"
+      ],
+      "owns": [
+        "euchre-authoritative-rules",
+        "euchre-legal-action-authority",
+        "euchre-safe-player-views",
+        "euchre-snapshot-validation"
+      ],
+      "doesNotOwn": [
+        "euchre-bot-action-selection",
+        "session-deadlines",
+        "networking",
+        "rendering"
+      ],
+      "compatibleWith": [
+        "miaoda-game-euchre-react"
+      ],
+      "useInsteadWhen": [],
+      "persistence": "snapshot",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "command",
+        "methods": {
+          "observe": "createEuchrePlayerView(state, playerId)",
+          "advance": "applyEuchreAction(state, action)"
+        }
+      }
+    },
+    "miaoda-game-euchre-react": {
+      "engine": "react",
+      "domains": [
+        "card-game",
+        "react",
+        "tabletop"
+      ],
+      "owns": [
+        "react-euchre-controller-lifecycle",
+        "react-euchre-safe-view-subscriptions",
+        "react-euchre-commit-projection"
+      ],
+      "doesNotOwn": [
+        "euchre-authoritative-rules",
+        "euchre-bot-action-selection",
+        "session-deadlines",
+        "networking",
+        "dom-layout"
+      ],
+      "compatibleWith": [
+        "miaoda-game-euchre-rules"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-euchre-rules",
+          "condition": "The host does not need React controller ownership or safe-view subscriptions."
+        }
+      ],
+      "persistence": "delegated",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "command",
+        "methods": {
+          "observe": "controller.view, useEuchreView(controller)",
+          "advance": "controller.dispatch(action)"
+        }
+      }
+    },
+    "miaoda-game-gin-rummy-rules": {
+      "engine": "neutral",
+      "domains": [
+        "card-game",
+        "rules",
+        "tabletop"
+      ],
+      "owns": [
+        "gin-rummy-authoritative-rules",
+        "gin-rummy-legal-action-authority",
+        "gin-rummy-safe-player-views",
+        "gin-rummy-snapshot-validation"
+      ],
+      "doesNotOwn": [
+        "gin-rummy-bot-action-selection",
+        "session-deadlines",
+        "networking",
+        "rendering"
+      ],
+      "compatibleWith": [
+        "miaoda-game-gin-rummy-react"
+      ],
+      "useInsteadWhen": [],
+      "persistence": "snapshot",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "command",
+        "methods": {
+          "observe": "createGinRummyPlayerView(state, playerId)",
+          "advance": "applyGinRummyAction(state, action)"
+        }
+      }
+    },
+    "miaoda-game-gin-rummy-react": {
+      "engine": "react",
+      "domains": [
+        "card-game",
+        "react",
+        "tabletop"
+      ],
+      "owns": [
+        "react-gin-rummy-controller-lifecycle",
+        "react-gin-rummy-safe-view-subscriptions",
+        "react-gin-rummy-commit-projection"
+      ],
+      "doesNotOwn": [
+        "gin-rummy-authoritative-rules",
+        "gin-rummy-bot-action-selection",
+        "session-deadlines",
+        "networking",
+        "dom-layout"
+      ],
+      "compatibleWith": [
+        "miaoda-game-gin-rummy-rules"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-gin-rummy-rules",
+          "condition": "The host does not need React controller ownership or safe-view subscriptions."
+        }
+      ],
+      "persistence": "delegated",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "command",
+        "methods": {
+          "observe": "controller.view, useGinRummyView(controller)",
+          "advance": "controller.dispatch(action)"
+        }
+      }
+    },
+    "miaoda-game-gong-zhu-rules": {
+      "engine": "neutral",
+      "domains": [
+        "card-game",
+        "rules",
+        "tabletop"
+      ],
+      "owns": [
+        "gong-zhu-authoritative-rules",
+        "gong-zhu-legal-action-authority",
+        "gong-zhu-safe-player-views",
+        "gong-zhu-snapshot-validation"
+      ],
+      "doesNotOwn": [
+        "gong-zhu-bot-action-selection",
+        "session-deadlines",
+        "networking",
+        "rendering"
+      ],
+      "compatibleWith": [
+        "miaoda-game-gong-zhu-react"
+      ],
+      "useInsteadWhen": [],
+      "persistence": "snapshot",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "command",
+        "methods": {
+          "observe": "createGongZhuPlayerView(state, playerId)",
+          "advance": "applyGongZhuAction(state, action)"
+        }
+      }
+    },
+    "miaoda-game-gong-zhu-react": {
+      "engine": "react",
+      "domains": [
+        "card-game",
+        "react",
+        "tabletop"
+      ],
+      "owns": [
+        "react-gong-zhu-controller-lifecycle",
+        "react-gong-zhu-safe-view-subscriptions",
+        "react-gong-zhu-commit-projection"
+      ],
+      "doesNotOwn": [
+        "gong-zhu-authoritative-rules",
+        "gong-zhu-bot-action-selection",
+        "session-deadlines",
+        "networking",
+        "dom-layout"
+      ],
+      "compatibleWith": [
+        "miaoda-game-gong-zhu-rules"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-gong-zhu-rules",
+          "condition": "The host does not need React controller ownership or safe-view subscriptions."
+        }
+      ],
+      "persistence": "delegated",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "command",
+        "methods": {
+          "observe": "controller.view, useGongZhuView(controller)",
+          "advance": "controller.dispatch(action)"
+        }
+      }
+    },
+    "miaoda-game-gou-ji-rules": {
+      "engine": "neutral",
+      "domains": [
+        "card-game",
+        "rules",
+        "tabletop"
+      ],
+      "owns": [
+        "gou-ji-authoritative-rules",
+        "gou-ji-legal-action-authority",
+        "gou-ji-safe-player-views",
+        "gou-ji-snapshot-validation"
+      ],
+      "doesNotOwn": [
+        "gou-ji-bot-action-selection",
+        "session-deadlines",
+        "networking",
+        "rendering"
+      ],
+      "compatibleWith": [
+        "miaoda-game-gou-ji-react",
+        "miaoda-game-gou-ji-analysis-core"
+      ],
+      "useInsteadWhen": [],
+      "persistence": "snapshot",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "command",
+        "methods": {
+          "observe": "createGouJiPlayerView(state, playerId)",
+          "advance": "applyGouJiAction(state, action)"
+        }
+      }
+    },
+    "miaoda-game-gou-ji-react": {
+      "engine": "react",
+      "domains": [
+        "card-game",
+        "react",
+        "tabletop"
+      ],
+      "owns": [
+        "react-gou-ji-controller-lifecycle",
+        "react-gou-ji-safe-view-subscriptions",
+        "react-gou-ji-commit-projection"
+      ],
+      "doesNotOwn": [
+        "gou-ji-authoritative-rules",
+        "gou-ji-bot-action-selection",
+        "session-deadlines",
+        "networking",
+        "dom-layout"
+      ],
+      "compatibleWith": [
+        "miaoda-game-gou-ji-rules",
+        "miaoda-game-gou-ji-analysis-core"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-gou-ji-rules",
+          "condition": "The host does not need React controller ownership or safe-view subscriptions."
+        }
+      ],
+      "persistence": "delegated",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "command",
+        "methods": {
+          "observe": "controller.view, useGouJiView(controller)",
+          "advance": "controller.dispatch(action)"
+        }
+      }
+    },
+    "miaoda-game-guandan-rules": {
+      "engine": "neutral",
+      "domains": [
+        "card-game",
+        "rules",
+        "tabletop"
+      ],
+      "owns": [
+        "guandan-authoritative-rules",
+        "guandan-legal-action-authority",
+        "guandan-safe-player-views",
+        "guandan-snapshot-validation"
+      ],
+      "doesNotOwn": [
+        "guandan-bot-action-selection",
+        "session-deadlines",
+        "networking",
+        "rendering"
+      ],
+      "compatibleWith": [
+        "miaoda-game-guandan-react",
+        "miaoda-game-guandan-analysis-core"
+      ],
+      "useInsteadWhen": [],
+      "persistence": "snapshot",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "command",
+        "methods": {
+          "observe": "createGuandanPlayerView(state, playerId)",
+          "advance": "applyGuandanAction(state, action)"
+        }
+      }
+    },
+    "miaoda-game-guandan-react": {
+      "engine": "react",
+      "domains": [
+        "card-game",
+        "react",
+        "tabletop"
+      ],
+      "owns": [
+        "react-guandan-controller-lifecycle",
+        "react-guandan-safe-view-subscriptions",
+        "react-guandan-commit-projection"
+      ],
+      "doesNotOwn": [
+        "guandan-authoritative-rules",
+        "guandan-bot-action-selection",
+        "session-deadlines",
+        "networking",
+        "dom-layout"
+      ],
+      "compatibleWith": [
+        "miaoda-game-guandan-rules",
+        "miaoda-game-guandan-analysis-core"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-guandan-rules",
+          "condition": "The host does not need React controller ownership or safe-view subscriptions."
+        }
+      ],
+      "persistence": "delegated",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "command",
+        "methods": {
+          "observe": "controller.view, useGuandanView(controller)",
+          "advance": "controller.dispatch(action)"
+        }
+      }
+    },
+    "miaoda-game-hearts-rules": {
+      "engine": "neutral",
+      "domains": [
+        "card-game",
+        "rules",
+        "tabletop"
+      ],
+      "owns": [
+        "hearts-authoritative-rules",
+        "hearts-legal-action-authority",
+        "hearts-safe-player-views",
+        "hearts-snapshot-validation"
+      ],
+      "doesNotOwn": [
+        "hearts-bot-action-selection",
+        "session-deadlines",
+        "networking",
+        "rendering"
+      ],
+      "compatibleWith": [
+        "miaoda-game-hearts-react"
+      ],
+      "useInsteadWhen": [],
+      "persistence": "snapshot",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "command",
+        "methods": {
+          "observe": "createHeartsPlayerView(state, playerId)",
+          "advance": "applyHeartsAction(state, action)"
+        }
+      }
+    },
+    "miaoda-game-hearts-react": {
+      "engine": "react",
+      "domains": [
+        "card-game",
+        "react",
+        "tabletop"
+      ],
+      "owns": [
+        "react-hearts-controller-lifecycle",
+        "react-hearts-safe-view-subscriptions",
+        "react-hearts-commit-projection"
+      ],
+      "doesNotOwn": [
+        "hearts-authoritative-rules",
+        "hearts-bot-action-selection",
+        "session-deadlines",
+        "networking",
+        "dom-layout"
+      ],
+      "compatibleWith": [
+        "miaoda-game-hearts-rules"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-hearts-rules",
+          "condition": "The host does not need React controller ownership or safe-view subscriptions."
+        }
+      ],
+      "persistence": "delegated",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "command",
+        "methods": {
+          "observe": "controller.view, useHeartsView(controller)",
+          "advance": "controller.dispatch(action)"
+        }
+      }
+    },
+    "miaoda-game-paodekuai-rules": {
+      "engine": "neutral",
+      "domains": [
+        "card-game",
+        "rules",
+        "tabletop"
+      ],
+      "owns": [
+        "paodekuai-authoritative-rules",
+        "paodekuai-legal-action-authority",
+        "paodekuai-safe-player-views",
+        "paodekuai-snapshot-validation"
+      ],
+      "doesNotOwn": [
+        "paodekuai-bot-action-selection",
+        "session-deadlines",
+        "networking",
+        "rendering"
+      ],
+      "compatibleWith": [
+        "miaoda-game-paodekuai-react"
+      ],
+      "useInsteadWhen": [],
+      "persistence": "snapshot",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "command",
+        "methods": {
+          "observe": "createPaoDeKuaiPlayerView(state, playerId)",
+          "advance": "applyPaoDeKuaiAction(state, action)"
+        }
+      }
+    },
+    "miaoda-game-paodekuai-react": {
+      "engine": "react",
+      "domains": [
+        "card-game",
+        "react",
+        "tabletop"
+      ],
+      "owns": [
+        "react-paodekuai-controller-lifecycle",
+        "react-paodekuai-safe-view-subscriptions",
+        "react-paodekuai-commit-projection"
+      ],
+      "doesNotOwn": [
+        "paodekuai-authoritative-rules",
+        "paodekuai-bot-action-selection",
+        "session-deadlines",
+        "networking",
+        "dom-layout"
+      ],
+      "compatibleWith": [
+        "miaoda-game-paodekuai-rules"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-paodekuai-rules",
+          "condition": "The host does not need React controller ownership or safe-view subscriptions."
+        }
+      ],
+      "persistence": "delegated",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "command",
+        "methods": {
+          "observe": "controller.view, usePaoDeKuaiView(controller)",
+          "advance": "controller.dispatch(action)"
+        }
+      }
+    },
+    "miaoda-game-spades-rules": {
+      "engine": "neutral",
+      "domains": [
+        "card-game",
+        "rules",
+        "tabletop"
+      ],
+      "owns": [
+        "spades-authoritative-rules",
+        "spades-legal-action-authority",
+        "spades-safe-player-views",
+        "spades-snapshot-validation"
+      ],
+      "doesNotOwn": [
+        "spades-bot-action-selection",
+        "session-deadlines",
+        "networking",
+        "rendering"
+      ],
+      "compatibleWith": [
+        "miaoda-game-spades-react"
+      ],
+      "useInsteadWhen": [],
+      "persistence": "snapshot",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "command",
+        "methods": {
+          "observe": "createSpadesPlayerView(state, playerId)",
+          "advance": "applySpadesAction(state, action)"
+        }
+      }
+    },
+    "miaoda-game-spades-react": {
+      "engine": "react",
+      "domains": [
+        "card-game",
+        "react",
+        "tabletop"
+      ],
+      "owns": [
+        "react-spades-controller-lifecycle",
+        "react-spades-safe-view-subscriptions",
+        "react-spades-commit-projection"
+      ],
+      "doesNotOwn": [
+        "spades-authoritative-rules",
+        "spades-bot-action-selection",
+        "session-deadlines",
+        "networking",
+        "dom-layout"
+      ],
+      "compatibleWith": [
+        "miaoda-game-spades-rules"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-spades-rules",
+          "condition": "The host does not need React controller ownership or safe-view subscriptions."
+        }
+      ],
+      "persistence": "delegated",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "command",
+        "methods": {
+          "observe": "controller.view, useSpadesView(controller)",
+          "advance": "controller.dispatch(action)"
+        }
+      }
+    },
+    "miaoda-game-texas-holdem-rules": {
+      "engine": "neutral",
+      "domains": [
+        "card-game",
+        "rules",
+        "tabletop"
+      ],
+      "owns": [
+        "texas-holdem-authoritative-rules",
+        "texas-holdem-legal-action-authority",
+        "texas-holdem-safe-player-views",
+        "texas-holdem-snapshot-validation"
+      ],
+      "doesNotOwn": [
+        "texas-holdem-bot-action-selection",
+        "session-deadlines",
+        "networking",
+        "rendering"
+      ],
+      "compatibleWith": [
+        "miaoda-game-texas-holdem-react"
+      ],
+      "useInsteadWhen": [],
+      "persistence": "snapshot",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "command",
+        "methods": {
+          "observe": "createTexasHoldemPlayerView(state, playerId)",
+          "advance": "applyTexasHoldemAction(state, action)"
+        }
+      }
+    },
+    "miaoda-game-texas-holdem-react": {
+      "engine": "react",
+      "domains": [
+        "card-game",
+        "react",
+        "tabletop"
+      ],
+      "owns": [
+        "react-texas-holdem-controller-lifecycle",
+        "react-texas-holdem-safe-view-subscriptions",
+        "react-texas-holdem-commit-projection"
+      ],
+      "doesNotOwn": [
+        "texas-holdem-authoritative-rules",
+        "texas-holdem-bot-action-selection",
+        "session-deadlines",
+        "networking",
+        "dom-layout"
+      ],
+      "compatibleWith": [
+        "miaoda-game-texas-holdem-rules"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-texas-holdem-rules",
+          "condition": "The host does not need React controller ownership or safe-view subscriptions."
+        }
+      ],
+      "persistence": "delegated",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "command",
+        "methods": {
+          "observe": "controller.view, useTexasHoldemView(controller)",
+          "advance": "controller.dispatch(action)"
+        }
+      }
+    },
+    "miaoda-game-thirteen-water-rules": {
+      "engine": "neutral",
+      "domains": [
+        "card-game",
+        "rules",
+        "tabletop"
+      ],
+      "owns": [
+        "thirteen-water-authoritative-rules",
+        "thirteen-water-legal-action-authority",
+        "thirteen-water-safe-player-views",
+        "thirteen-water-snapshot-validation"
+      ],
+      "doesNotOwn": [
+        "thirteen-water-bot-action-selection",
+        "session-deadlines",
+        "networking",
+        "rendering"
+      ],
+      "compatibleWith": [
+        "miaoda-game-thirteen-water-react",
+        "miaoda-game-thirteen-water-analysis-core"
+      ],
+      "useInsteadWhen": [],
+      "persistence": "snapshot",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "command",
+        "methods": {
+          "observe": "createThirteenWaterPlayerView(state, playerId)",
+          "advance": "applyThirteenWaterAction(state, action)"
+        }
+      }
+    },
+    "miaoda-game-thirteen-water-react": {
+      "engine": "react",
+      "domains": [
+        "card-game",
+        "react",
+        "tabletop"
+      ],
+      "owns": [
+        "react-thirteen-water-controller-lifecycle",
+        "react-thirteen-water-safe-view-subscriptions",
+        "react-thirteen-water-commit-projection"
+      ],
+      "doesNotOwn": [
+        "thirteen-water-authoritative-rules",
+        "thirteen-water-bot-action-selection",
+        "session-deadlines",
+        "networking",
+        "dom-layout"
+      ],
+      "compatibleWith": [
+        "miaoda-game-thirteen-water-rules",
+        "miaoda-game-thirteen-water-analysis-core"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-thirteen-water-rules",
+          "condition": "The host does not need React controller ownership or safe-view subscriptions."
+        }
+      ],
+      "persistence": "delegated",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "command",
+        "methods": {
+          "observe": "controller.view, useThirteenWaterView(controller)",
+          "advance": "controller.dispatch(action)"
+        }
+      }
+    },
+    "miaoda-game-tractor-rules": {
+      "engine": "neutral",
+      "domains": [
+        "card-game",
+        "rules",
+        "tabletop"
+      ],
+      "owns": [
+        "tractor-authoritative-rules",
+        "tractor-legal-action-authority",
+        "tractor-safe-player-views",
+        "tractor-snapshot-validation"
+      ],
+      "doesNotOwn": [
+        "tractor-bot-action-selection",
+        "session-deadlines",
+        "networking",
+        "rendering"
+      ],
+      "compatibleWith": [
+        "miaoda-game-tractor-react",
+        "miaoda-game-tractor-analysis-core"
+      ],
+      "useInsteadWhen": [],
+      "persistence": "snapshot",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "command",
+        "methods": {
+          "observe": "getTractorDealPlayerView(state, playerId)",
+          "advance": "applyTractorDeal(state, action)"
+        }
+      }
+    },
+    "miaoda-game-tractor-react": {
+      "engine": "react",
+      "domains": [
+        "card-game",
+        "react",
+        "tabletop"
+      ],
+      "owns": [
+        "react-tractor-controller-lifecycle",
+        "react-tractor-safe-view-subscriptions",
+        "react-tractor-commit-projection"
+      ],
+      "doesNotOwn": [
+        "tractor-authoritative-rules",
+        "tractor-bot-action-selection",
+        "session-deadlines",
+        "networking",
+        "dom-layout"
+      ],
+      "compatibleWith": [
+        "miaoda-game-tractor-rules",
+        "miaoda-game-tractor-analysis-core"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-tractor-rules",
+          "condition": "The host does not need React controller ownership or safe-view subscriptions."
+        }
+      ],
+      "persistence": "delegated",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "command",
+        "methods": {
+          "observe": "controller.view, useTractorView(controller)",
+          "advance": "controller.dispatch(action)"
+        }
+      }
+    },
+    "miaoda-game-zha-jinhua-rules": {
+      "engine": "neutral",
+      "domains": [
+        "card-game",
+        "rules",
+        "tabletop"
+      ],
+      "owns": [
+        "zha-jinhua-authoritative-rules",
+        "zha-jinhua-legal-action-authority",
+        "zha-jinhua-safe-player-views",
+        "zha-jinhua-snapshot-validation"
+      ],
+      "doesNotOwn": [
+        "zha-jinhua-bot-action-selection",
+        "session-deadlines",
+        "networking",
+        "rendering"
+      ],
+      "compatibleWith": [
+        "miaoda-game-zha-jinhua-react"
+      ],
+      "useInsteadWhen": [],
+      "persistence": "snapshot",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "command",
+        "methods": {
+          "observe": "createZhaJinhuaPlayerView(state, playerId)",
+          "advance": "applyZhaJinhuaAction(state, action)"
+        }
+      }
+    },
+    "miaoda-game-zha-jinhua-react": {
+      "engine": "react",
+      "domains": [
+        "card-game",
+        "react",
+        "tabletop"
+      ],
+      "owns": [
+        "react-zha-jinhua-controller-lifecycle",
+        "react-zha-jinhua-safe-view-subscriptions",
+        "react-zha-jinhua-commit-projection"
+      ],
+      "doesNotOwn": [
+        "zha-jinhua-authoritative-rules",
+        "zha-jinhua-bot-action-selection",
+        "session-deadlines",
+        "networking",
+        "dom-layout"
+      ],
+      "compatibleWith": [
+        "miaoda-game-zha-jinhua-rules"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-zha-jinhua-rules",
+          "condition": "The host does not need React controller ownership or safe-view subscriptions."
+        }
+      ],
+      "persistence": "delegated",
+      "testability": {
+        "observation": "snapshot-and-result",
+        "advance": "command",
+        "methods": {
+          "observe": "controller.view, useZhaJinhuaView(controller)",
+          "advance": "controller.dispatch(action)"
+        }
+      }
+    },
+    "miaoda-game-bridge-strategy-core": {
+      "engine": "neutral",
+      "domains": [
+        "ai",
+        "card-game",
+        "strategy"
+      ],
+      "owns": [
+        "bridge-bot-action-selection",
+        "bridge-bot-auction-policy",
+        "bridge-bot-card-play-policy"
+      ],
+      "doesNotOwn": [
+        "bridge-authoritative-rules",
+        "bridge-action-scheduling",
+        "hidden-opponent-state",
+        "rendering"
+      ],
+      "compatibleWith": [
+        "miaoda-game-bridge-rules",
+        "miaoda-game-bridge-react"
+      ],
+      "useInsteadWhen": [],
+      "persistence": "none"
+    },
+    "miaoda-game-canasta-analysis-core": {
+      "engine": "neutral",
+      "domains": [
+        "analysis",
+        "card-game",
+        "tabletop"
+      ],
+      "owns": [
+        "canasta-card-value-analysis",
+        "canasta-meld-candidate-analysis",
+        "canasta-initial-meld-thresholds",
+        "canasta-discard-pile-eligibility"
+      ],
+      "doesNotOwn": [
+        "canasta-authoritative-rules",
+        "canasta-bot-action-selection",
+        "turn-orchestration",
+        "rendering"
+      ],
+      "compatibleWith": [
+        "miaoda-game-canasta-rules",
+        "miaoda-game-canasta-react"
+      ],
+      "useInsteadWhen": [],
+      "persistence": "none"
+    },
+    "miaoda-game-gou-ji-analysis-core": {
+      "engine": "neutral",
+      "domains": [
+        "analysis",
+        "card-game",
+        "tabletop"
+      ],
+      "owns": [
+        "gou-ji-play-classification",
+        "gou-ji-play-comparison",
+        "gou-ji-trigger-analysis",
+        "gou-ji-legal-play-enumeration"
+      ],
+      "doesNotOwn": [
+        "gou-ji-authoritative-rules",
+        "gou-ji-bot-action-selection",
+        "match-orchestration",
+        "rendering"
+      ],
+      "compatibleWith": [
+        "miaoda-game-gou-ji-rules",
+        "miaoda-game-gou-ji-react"
+      ],
+      "useInsteadWhen": [],
+      "persistence": "none"
+    },
+    "miaoda-game-guandan-analysis-core": {
+      "engine": "neutral",
+      "domains": [
+        "analysis",
+        "card-game",
+        "tabletop"
+      ],
+      "owns": [
+        "guandan-play-classification",
+        "guandan-play-comparison",
+        "guandan-wildcard-analysis",
+        "guandan-legal-play-enumeration"
+      ],
+      "doesNotOwn": [
+        "guandan-authoritative-rules",
+        "guandan-bot-action-selection",
+        "match-orchestration",
+        "rendering"
+      ],
+      "compatibleWith": [
+        "miaoda-game-guandan-rules",
+        "miaoda-game-guandan-react"
+      ],
+      "useInsteadWhen": [],
+      "persistence": "none"
+    },
+    "miaoda-game-thirteen-water-analysis-core": {
+      "engine": "neutral",
+      "domains": [
+        "analysis",
+        "card-game",
+        "tabletop"
+      ],
+      "owns": [
+        "thirteen-water-arrangement-validation",
+        "thirteen-water-arrangement-enumeration",
+        "thirteen-water-hand-comparison",
+        "thirteen-water-foul-detection"
+      ],
+      "doesNotOwn": [
+        "thirteen-water-authoritative-rules",
+        "thirteen-water-bot-action-selection",
+        "match-orchestration",
+        "rendering"
+      ],
+      "compatibleWith": [
+        "miaoda-game-thirteen-water-rules",
+        "miaoda-game-thirteen-water-react"
+      ],
+      "useInsteadWhen": [],
+      "persistence": "none"
+    },
+    "miaoda-game-tractor-analysis-core": {
+      "engine": "neutral",
+      "domains": [
+        "analysis",
+        "card-game",
+        "tabletop"
+      ],
+      "owns": [
+        "tractor-play-classification",
+        "tractor-follow-obligation-analysis",
+        "tractor-trick-winner-analysis",
+        "tractor-settlement-analysis"
+      ],
+      "doesNotOwn": [
+        "tractor-authoritative-rules",
+        "tractor-bot-action-selection",
+        "match-orchestration",
+        "rendering"
+      ],
+      "compatibleWith": [
+        "miaoda-game-tractor-rules",
+        "miaoda-game-tractor-react"
+      ],
+      "useInsteadWhen": [],
+      "persistence": "none"
+    },
+    "miaoda-game-bridge-tournament-core": {
+      "engine": "neutral",
+      "domains": [
+        "bridge",
+        "card-game",
+        "tabletop",
+        "tournament"
+      ],
+      "owns": [
+        "bridge-mitchell-pairs-movement",
+        "bridge-matchpoint-standings",
+        "bridge-team-imp-aggregation",
+        "bridge-tournament-command-validation",
+        "bridge-tournament-public-views"
+      ],
+      "doesNotOwn": [
+        "bridge-table-play-rules",
+        "bridge-bot-action-selection",
+        "tournament-networking",
+        "tournament-clocks",
+        "rendering"
+      ],
+      "compatibleWith": [
+        "miaoda-game-bridge-rules",
+        "miaoda-game-bridge-tournament-react"
+      ],
+      "useInsteadWhen": [],
+      "persistence": "snapshot"
+    },
+    "miaoda-game-bridge-tournament-react": {
+      "engine": "react",
+      "domains": [
+        "bridge",
+        "card-game",
+        "tabletop",
+        "tournament",
+        "react"
+      ],
+      "owns": [
+        "react-bridge-tournament-controller",
+        "react-bridge-public-view-subscriptions"
+      ],
+      "doesNotOwn": [
+        "bridge-tournament-rules",
+        "bridge-table-play-rules",
+        "networking",
+        "dom-layout"
+      ],
+      "compatibleWith": [
+        "miaoda-game-bridge-tournament-core",
+        "miaoda-game-bridge-rules"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-bridge-tournament-core",
+          "condition": "The host does not need react lifecycle or presentation integration."
+        }
+      ],
+      "persistence": "delegated"
+    },
+    "miaoda-game-meld-core": {
+      "engine": "neutral",
+      "domains": [
+        "analysis",
+        "card-game",
+        "tabletop"
+      ],
+      "owns": [
+        "disjoint-meld-partition-search",
+        "minimum-unused-card-optimization",
+        "deterministic-meld-tie-breaking"
+      ],
+      "doesNotOwn": [
+        "meld-candidate-generation",
+        "card-game-rules",
+        "card-scoring-policy",
+        "turn-orchestration",
+        "rendering"
+      ],
+      "compatibleWith": [
+        "miaoda-game-gin-rummy-rules",
+        "miaoda-game-canasta-rules"
+      ],
+      "useInsteadWhen": [],
+      "persistence": "none"
+    },
+    "miaoda-game-trick-taking-core": {
+      "engine": "neutral",
+      "domains": [
+        "card-game",
+        "rules",
+        "tabletop"
+      ],
+      "owns": [
+        "trick-seat-order",
+        "follow-suit-legality",
+        "trump-winner-resolution",
+        "trick-history",
+        "trick-state-validation"
+      ],
+      "doesNotOwn": [
+        "bidding-rules",
+        "match-scoring",
+        "multi-card-tricks",
+        "card-ownership",
+        "rendering"
+      ],
+      "compatibleWith": [
+        "miaoda-game-bridge-rules",
+        "miaoda-game-euchre-rules",
+        "miaoda-game-hearts-rules",
+        "miaoda-game-spades-rules"
+      ],
+      "useInsteadWhen": [],
+      "persistence": "snapshot"
+    },
+    "miaoda-game-deck-core": {
+      "engine": "neutral",
+      "domains": [
+        "card-game",
+        "deck",
+        "tabletop"
+      ],
+      "owns": [
+        "deck-zone-ownership",
+        "card-instance-identity",
+        "deterministic-shuffle",
+        "atomic-card-movement",
+        "deck-snapshots"
+      ],
+      "doesNotOwn": [
+        "card-effects",
+        "card-play-legality",
+        "turn-orchestration",
+        "hidden-information-projection",
+        "rendering"
+      ],
+      "compatibleWith": [
+        "miaoda-game-deck-cocos",
+        "miaoda-game-deck-phaser",
+        "miaoda-game-deck-react",
+        "miaoda-game-turn-core"
+      ],
+      "useInsteadWhen": [],
+      "persistence": "snapshot"
+    },
+    "miaoda-game-deck-cocos": {
+      "engine": "cocos",
+      "domains": [
+        "card-game",
+        "deck",
+        "tabletop",
+        "cocos"
+      ],
+      "owns": [
+        "cocos-deck-component-lifecycle",
+        "cocos-deck-event-forwarding"
+      ],
+      "doesNotOwn": [
+        "card-rules",
+        "card-node-layout",
+        "input-handling",
+        "hidden-information-projection"
+      ],
+      "compatibleWith": [
+        "miaoda-game-deck-core"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-deck-core",
+          "condition": "The host does not need cocos lifecycle or presentation integration."
+        }
+      ],
+      "persistence": "delegated"
+    },
+    "miaoda-game-deck-phaser": {
+      "engine": "phaser",
+      "domains": [
+        "card-game",
+        "deck",
+        "tabletop",
+        "phaser"
+      ],
+      "owns": [
+        "phaser-deck-scene-lifecycle",
+        "phaser-deck-observable-ownership"
+      ],
+      "doesNotOwn": [
+        "card-rules",
+        "card-game-objects",
+        "input-handling",
+        "hidden-information-projection"
+      ],
+      "compatibleWith": [
+        "miaoda-game-deck-core"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-deck-core",
+          "condition": "The host does not need phaser lifecycle or presentation integration."
+        }
+      ],
+      "persistence": "delegated"
+    },
+    "miaoda-game-deck-react": {
+      "engine": "react",
+      "domains": [
+        "card-game",
+        "deck",
+        "tabletop",
+        "react"
+      ],
+      "owns": [
+        "react-deck-instance-lifecycle",
+        "react-deck-snapshot-subscriptions"
+      ],
+      "doesNotOwn": [
+        "card-rules",
+        "turn-flow",
+        "hidden-information-projection",
+        "dom-layout"
+      ],
+      "compatibleWith": [
+        "miaoda-game-deck-core"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-deck-core",
+          "condition": "The host does not need react lifecycle or presentation integration."
+        }
+      ],
+      "persistence": "delegated"
+    },
+    "miaoda-game-deckbuilder-core": {
+      "engine": "neutral",
+      "domains": [
+        "card-game",
+        "deckbuilder",
+        "tabletop"
+      ],
+      "owns": [
+        "deckbuilder-card-instance-identity",
+        "deckbuilder-battle-phases",
+        "deckbuilder-energy-legality",
+        "deckbuilder-command-validation",
+        "deckbuilder-snapshots"
+      ],
+      "doesNotOwn": [
+        "card-effect-language",
+        "combat-formulas",
+        "enemy-ai",
+        "run-progression",
+        "rendering"
+      ],
+      "compatibleWith": [],
+      "useInsteadWhen": [],
+      "persistence": "snapshot"
+    },
+    "miaoda-game-draft-pool-core": {
+      "engine": "neutral",
+      "domains": [
+        "card-game",
+        "draft",
+        "tabletop"
+      ],
+      "owns": [
+        "finite-draft-pool",
+        "weighted-draft-offers",
+        "draft-reservation-lifecycle",
+        "draft-conservation-checks",
+        "draft-snapshots"
+      ],
+      "doesNotOwn": [
+        "draft-item-effects",
+        "player-economy",
+        "matchmaking",
+        "rendering"
+      ],
+      "compatibleWith": [
+        "miaoda-game-draft-pool-react"
+      ],
+      "useInsteadWhen": [],
+      "persistence": "snapshot"
+    },
+    "miaoda-game-draft-pool-react": {
+      "engine": "react",
+      "domains": [
+        "card-game",
+        "draft",
+        "tabletop",
+        "react"
+      ],
+      "owns": [
+        "react-draft-pool-controller",
+        "react-draft-pool-subscriptions"
+      ],
+      "doesNotOwn": [
+        "draft-pool-rules",
+        "player-economy",
+        "drag-interactions",
+        "dom-layout"
+      ],
+      "compatibleWith": [
+        "miaoda-game-draft-pool-core"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-draft-pool-core",
+          "condition": "The host does not need react lifecycle or presentation integration."
+        }
+      ],
+      "persistence": "delegated"
+    },
+    "miaoda-game-grid-cocos": {
+      "engine": "cocos",
+      "domains": [
+        "board-game",
+        "grid",
+        "tabletop",
+        "cocos"
+      ],
+      "owns": [
+        "cocos-grid-layout-projection",
+        "cocos-grid-input-translation"
+      ],
+      "doesNotOwn": [
+        "grid-topology-rules",
+        "piece-movement-rules",
+        "game-outcomes",
+        "rendering-assets"
+      ],
+      "compatibleWith": [
+        "miaoda-game-grid-core"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-grid-core",
+          "condition": "The host does not need cocos lifecycle or presentation integration."
+        }
+      ],
+      "persistence": "delegated"
+    },
+    "miaoda-game-grid-phaser": {
+      "engine": "phaser",
+      "domains": [
+        "board-game",
+        "grid",
+        "tabletop",
+        "phaser"
+      ],
+      "owns": [
+        "phaser-grid-layout-projection",
+        "phaser-grid-input-translation",
+        "phaser-grid-movement-projection"
+      ],
+      "doesNotOwn": [
+        "grid-topology-rules",
+        "piece-movement-rules",
+        "game-outcomes",
+        "rendering-assets"
+      ],
+      "compatibleWith": [
+        "miaoda-game-grid-core"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-grid-core",
+          "condition": "The host does not need phaser lifecycle or presentation integration."
+        }
+      ],
+      "persistence": "delegated"
+    },
+    "miaoda-game-grid-react": {
+      "engine": "react",
+      "domains": [
+        "board-game",
+        "grid",
+        "tabletop",
+        "react"
+      ],
+      "owns": [
+        "react-grid-state-subscriptions",
+        "react-grid-transaction-projection"
+      ],
+      "doesNotOwn": [
+        "grid-game-rules",
+        "piece-art",
+        "drag-interactions",
+        "dom-layout"
+      ],
+      "compatibleWith": [
+        "miaoda-game-grid-core"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-grid-core",
+          "condition": "The host does not need react lifecycle or presentation integration."
+        }
+      ],
+      "persistence": "delegated"
+    },
+    "miaoda-game-grid-piece-core": {
+      "engine": "neutral",
+      "domains": [
+        "board-game",
+        "grid",
+        "tabletop"
+      ],
+      "owns": [
+        "multi-cell-piece-footprints",
+        "grid-piece-occupancy",
+        "grid-piece-fit-validation",
+        "grid-piece-sliding",
+        "grid-piece-rotation"
+      ],
+      "doesNotOwn": [
+        "board-game-rules",
+        "puzzle-solving",
+        "equipment-slots",
+        "rendering"
+      ],
+      "compatibleWith": [
+        "miaoda-game-grid-core",
+        "miaoda-game-grid-piece-react"
+      ],
+      "useInsteadWhen": [],
+      "persistence": "snapshot"
+    },
+    "miaoda-game-grid-piece-react": {
+      "engine": "react",
+      "domains": [
+        "board-game",
+        "grid",
+        "tabletop",
+        "react"
+      ],
+      "owns": [
+        "react-grid-piece-subscriptions",
+        "react-grid-piece-command-projection"
+      ],
+      "doesNotOwn": [
+        "board-game-rules",
+        "drag-interactions",
+        "piece-animation",
+        "dom-layout"
+      ],
+      "compatibleWith": [
+        "miaoda-game-grid-piece-core",
+        "miaoda-game-grid-core"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-grid-piece-core",
+          "condition": "The host does not need react lifecycle or presentation integration."
+        }
+      ],
+      "persistence": "delegated"
+    },
+    "miaoda-game-turn-core": {
+      "engine": "neutral",
+      "domains": [
+        "tabletop",
+        "turn-based"
+      ],
+      "owns": [
+        "ordered-actor-turns",
+        "faction-phase-turns",
+        "seat-based-turns",
+        "simultaneous-submission-barriers",
+        "turn-state-validation"
+      ],
+      "doesNotOwn": [
+        "game-action-legality",
+        "game-outcomes",
+        "networking",
+        "rendering"
+      ],
+      "compatibleWith": [
+        "miaoda-game-turn-cocos",
+        "miaoda-game-turn-phaser",
+        "miaoda-game-turn-react",
+        "miaoda-game-deck-core"
+      ],
+      "useInsteadWhen": [],
+      "persistence": "snapshot"
+    },
+    "miaoda-game-turn-cocos": {
+      "engine": "cocos",
+      "domains": [
+        "tabletop",
+        "turn-based",
+        "cocos"
+      ],
+      "owns": [
+        "cocos-turn-component-lifecycle",
+        "cocos-turn-change-forwarding"
+      ],
+      "doesNotOwn": [
+        "game-action-legality",
+        "networking",
+        "turn-ui-layout",
+        "rendering-assets"
+      ],
+      "compatibleWith": [
+        "miaoda-game-turn-core"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-turn-core",
+          "condition": "The host does not need cocos lifecycle or presentation integration."
+        }
+      ],
+      "persistence": "delegated"
+    },
+    "miaoda-game-turn-phaser": {
+      "engine": "phaser",
+      "domains": [
+        "tabletop",
+        "turn-based",
+        "phaser"
+      ],
+      "owns": [
+        "phaser-turn-scene-lifecycle",
+        "phaser-turn-observable-ownership"
+      ],
+      "doesNotOwn": [
+        "game-action-legality",
+        "networking",
+        "turn-ui-layout",
+        "rendering-assets"
+      ],
+      "compatibleWith": [
+        "miaoda-game-turn-core"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-turn-core",
+          "condition": "The host does not need phaser lifecycle or presentation integration."
+        }
+      ],
+      "persistence": "delegated"
+    },
+    "miaoda-game-turn-react": {
+      "engine": "react",
+      "domains": [
+        "tabletop",
+        "turn-based",
+        "react"
+      ],
+      "owns": [
+        "react-turn-controller-lifecycle",
+        "react-turn-state-subscriptions"
+      ],
+      "doesNotOwn": [
+        "game-action-legality",
+        "networking",
+        "turn-ui-layout",
+        "dom-layout"
+      ],
+      "compatibleWith": [
+        "miaoda-game-turn-core"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-turn-core",
+          "condition": "The host does not need react lifecycle or presentation integration."
+        }
+      ],
+      "persistence": "delegated"
+    },
+    "miaoda-game-sports-ball-core": {
+      "engine": "neutral",
+      "domains": [
+        "ball-game",
+        "physics",
+        "sports"
+      ],
+      "owns": [
+        "sports-ball-held-free-state",
+        "sports-ball-flat-field-motion",
+        "sports-ball-airborne-arcs",
+        "sports-ball-control-contests",
+        "sports-ball-trajectory-prediction",
+        "sports-ball-boundary-crossings"
+      ],
+      "doesNotOwn": [
+        "player-movement",
+        "sport-specific-rules",
+        "team-ai",
+        "collision-geometry",
+        "rendering"
+      ],
+      "compatibleWith": [
+        "miaoda-game-ballistics-core"
+      ],
+      "useInsteadWhen": [],
+      "persistence": "snapshot"
+    },
+    "miaoda-game-road-core": {
+      "engine": "neutral",
+      "domains": [
+        "racing",
+        "sports",
+        "vehicle"
+      ],
+      "owns": [
+        "segmented-racing-road",
+        "road-curve-projection",
+        "road-hill-occlusion",
+        "road-billboard-geometry"
+      ],
+      "doesNotOwn": [
+        "vehicle-kinematics",
+        "race-rules",
+        "collision",
+        "rendering"
+      ],
+      "compatibleWith": [
+        "miaoda-game-road-cocos",
+        "miaoda-game-road-phaser",
+        "miaoda-game-arcade-motion-core"
+      ],
+      "useInsteadWhen": [],
+      "persistence": "none"
+    },
+    "miaoda-game-road-cocos": {
+      "engine": "cocos",
+      "domains": [
+        "racing",
+        "sports",
+        "vehicle",
+        "cocos"
+      ],
+      "owns": [
+        "cocos-road-ribbon-rendering",
+        "cocos-road-billboard-projection"
+      ],
+      "doesNotOwn": [
+        "vehicle-kinematics",
+        "race-rules",
+        "collision",
+        "rendering-assets"
+      ],
+      "compatibleWith": [
+        "miaoda-game-road-core"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-road-core",
+          "condition": "The host does not need cocos lifecycle or presentation integration."
+        }
+      ],
+      "persistence": "delegated"
+    },
+    "miaoda-game-road-phaser": {
+      "engine": "phaser",
+      "domains": [
+        "racing",
+        "sports",
+        "vehicle",
+        "phaser"
+      ],
+      "owns": [
+        "phaser-road-graphics-rendering",
+        "phaser-road-frame-projection"
+      ],
+      "doesNotOwn": [
+        "vehicle-kinematics",
+        "race-rules",
+        "collision",
+        "rendering-assets"
+      ],
+      "compatibleWith": [
+        "miaoda-game-road-core"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-road-core",
+          "condition": "The host does not need phaser lifecycle or presentation integration."
+        }
+      ],
+      "persistence": "delegated"
+    },
+    "miaoda-game-pinball-core": {
+      "engine": "neutral",
+      "domains": [
+        "arcade",
+        "ball-game",
+        "pinball"
+      ],
+      "owns": [
+        "pinball-session-lifecycle",
+        "pinball-ball-save",
+        "pinball-multiball",
+        "pinball-tilt-state",
+        "pinball-switch-rules",
+        "pinball-flow-tracking"
+      ],
+      "doesNotOwn": [
+        "rigid-body-physics",
+        "table-geometry",
+        "flipper-impulses",
+        "audio",
+        "rendering"
+      ],
+      "compatibleWith": [
+        "miaoda-game-pinball-cocos",
+        "miaoda-game-pinball-phaser",
+        "miaoda-game-score-core"
+      ],
+      "useInsteadWhen": [],
+      "persistence": "snapshot"
+    },
+    "miaoda-game-pinball-cocos": {
+      "engine": "cocos",
+      "domains": [
+        "arcade",
+        "ball-game",
+        "pinball",
+        "cocos"
+      ],
+      "owns": [
+        "cocos-pinball-table-lifecycle",
+        "cocos-pinball-physics-contacts",
+        "cocos-pinball-actuator-components"
+      ],
+      "doesNotOwn": [
+        "pinball-rules",
+        "table-specific-geometry",
+        "visual-effects",
+        "audio"
+      ],
+      "compatibleWith": [
+        "miaoda-game-pinball-core",
+        "miaoda-game-score-core"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-pinball-core",
+          "condition": "The host does not need cocos lifecycle or presentation integration."
+        }
+      ],
+      "persistence": "delegated"
+    },
+    "miaoda-game-pinball-phaser": {
+      "engine": "phaser",
+      "domains": [
+        "arcade",
+        "ball-game",
+        "pinball",
+        "phaser"
+      ],
+      "owns": [
+        "phaser-pinball-scene-lifecycle",
+        "phaser-pinball-object-registration",
+        "phaser-pinball-time-bridging"
+      ],
+      "doesNotOwn": [
+        "pinball-rules",
+        "physics-body-creation",
+        "table-specific-geometry",
+        "visual-effects"
+      ],
+      "compatibleWith": [
+        "miaoda-game-pinball-core",
+        "miaoda-game-score-core"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-pinball-core",
+          "condition": "The host does not need phaser lifecycle or presentation integration."
+        }
+      ],
+      "persistence": "delegated"
+    },
+    "miaoda-game-score-core": {
+      "engine": "neutral",
+      "domains": [
+        "arcade",
+        "scoring",
+        "sports"
+      ],
+      "owns": [
+        "score-ledger",
+        "score-multipliers",
+        "timed-score-combos",
+        "high-score-state",
+        "score-snapshots"
+      ],
+      "doesNotOwn": [
+        "score-award-policy",
+        "leaderboard-services",
+        "game-clock",
+        "hud-rendering"
+      ],
+      "compatibleWith": [
+        "miaoda-game-score-phaser",
+        "miaoda-game-score-react",
+        "miaoda-game-pinball-core"
+      ],
+      "useInsteadWhen": [],
+      "persistence": "snapshot"
+    },
+    "miaoda-game-score-phaser": {
+      "engine": "phaser",
+      "domains": [
+        "arcade",
+        "scoring",
+        "sports",
+        "phaser"
+      ],
+      "owns": [
+        "phaser-score-scene-lifecycle",
+        "phaser-score-combo-time-bridging"
+      ],
+      "doesNotOwn": [
+        "score-award-policy",
+        "leaderboard-services",
+        "hud-rendering",
+        "game-pause-policy"
+      ],
+      "compatibleWith": [
+        "miaoda-game-score-core"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-score-core",
+          "condition": "The host does not need phaser lifecycle or presentation integration."
+        }
+      ],
+      "persistence": "delegated"
+    },
+    "miaoda-game-score-react": {
+      "engine": "react",
+      "domains": [
+        "arcade",
+        "scoring",
+        "sports",
+        "react"
+      ],
+      "owns": [
+        "react-score-controller-lifecycle",
+        "react-score-state-subscriptions"
+      ],
+      "doesNotOwn": [
+        "score-award-policy",
+        "game-clock",
+        "leaderboard-services",
+        "dom-layout"
+      ],
+      "compatibleWith": [
+        "miaoda-game-score-core"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-score-core",
+          "condition": "The host does not need react lifecycle or presentation integration."
+        }
+      ],
+      "persistence": "delegated"
+    },
+    "miaoda-game-roster-core": {
+      "engine": "neutral",
+      "domains": [
+        "lineup",
+        "roster",
+        "sports",
+        "tabletop"
+      ],
+      "owns": [
+        "roster-instance-identity",
+        "roster-zone-capacity",
+        "roster-eligibility",
+        "roster-atomic-transfers",
+        "roster-merge-resolution",
+        "roster-trait-derivation"
+      ],
+      "doesNotOwn": [
+        "spatial-placement",
+        "sport-specific-lineup-rules",
+        "combat",
+        "rendering"
+      ],
+      "compatibleWith": [
+        "miaoda-game-roster-react",
+        "miaoda-game-grid-core",
+        "miaoda-game-grid-piece-core"
+      ],
+      "useInsteadWhen": [],
+      "persistence": "snapshot"
+    },
+    "miaoda-game-roster-react": {
+      "engine": "react",
+      "domains": [
+        "lineup",
+        "roster",
+        "sports",
+        "tabletop",
+        "react"
+      ],
+      "owns": [
+        "react-roster-snapshot-subscriptions"
+      ],
+      "doesNotOwn": [
+        "roster-rules",
+        "spatial-placement",
+        "drag-interactions",
+        "merge-animation",
+        "dom-layout"
+      ],
+      "compatibleWith": [
+        "miaoda-game-roster-core"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-roster-core",
+          "condition": "The host does not need react lifecycle or presentation integration."
+        }
+      ],
+      "persistence": "delegated"
+    },
+    "miaoda-game-ballistics-core": {
+      "engine": "neutral",
+      "domains": [
+        "ball-game",
+        "physics",
+        "sports",
+        "trajectory"
+      ],
+      "owns": [
+        "projectile-motion-integration",
+        "ballistic-launch-solving",
+        "trajectory-sampling",
+        "landing-prediction",
+        "bounce-velocity",
+        "aerodynamic-acceleration"
+      ],
+      "doesNotOwn": [
+        "collision-world",
+        "damage",
+        "sport-specific-rules",
+        "rigid-body-integration",
+        "rendering"
+      ],
+      "compatibleWith": [
+        "miaoda-game-sports-ball-core"
+      ],
+      "useInsteadWhen": [
+        {
+          "package": "miaoda-game-sports-ball-core",
+          "condition": "The game needs authoritative held/free ownership, rolling, bounce/settle events, control contests, or interception prediction on a flat sports field."
+        }
+      ],
+      "persistence": "none"
+    },
+    "miaoda-game-mode7-core": {
+      "engine": "neutral",
+      "domains": [
+        "perspective",
+        "racing",
+        "sports"
+      ],
+      "owns": [
+        "mode7-affine-coordinate-mapping",
+        "mode7-perspective-scanlines",
+        "mode7-ground-point-projection"
+      ],
+      "doesNotOwn": [
+        "image-sampling",
+        "shaders",
+        "heightfield-terrain",
+        "vehicle-kinematics",
+        "rendering"
+      ],
+      "compatibleWith": [
+        "miaoda-game-road-core"
+      ],
+      "useInsteadWhen": [],
+      "persistence": "none"
+    }
+  }
+}