Deploy browser app plus Blender and Unreal handoff

.gitattributes

@@ -33,3 +33,9 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+native/art/generated/body-preview.png filter=lfs diff=lfs merge=lfs -text
+native/art/generated/cargo_and_finish.glb filter=lfs diff=lfs merge=lfs -text
+native/art/generated/course-preview.png filter=lfs diff=lfs merge=lfs -text
+native/art/generated/course_modules.glb filter=lfs diff=lfs merge=lfs -text
+native/art/generated/singularity-art.blend filter=lfs diff=lfs merge=lfs -text
+native/art/generated/singularity_body.glb filter=lfs diff=lfs merge=lfs -text

README.md

@@ -38,7 +38,7 @@ This initial competitive course uses a custom constrained-body solver and proced
 
 ## Unreal and Blender handoff
 
-The Blender artwork is available in [`art/generated/singularity-art.blend`](art/generated/singularity-art.blend), with three exported GLBs and inspected Cycles previews. The industrial robot has six independent parts, painted metal, rubber joints, optical lenses, and embedded PBR textures. The course includes detailed decking, bridge, cargo, and finish assets. See [`unreal/README.md`](unreal/README.md) for regeneration and import instructions. The Unreal source includes corrected coordinate mapping and input handling, but remains uncompiled here; its SpacetimeDB bridge is an event interface and still needs a network transport. No skeletal animation or native multiplayer is claimed.
+The Blender artwork is available in [`art/generated/singularity-art.blend`](art/generated/singularity-art.blend), with three exported GLBs and inspected Cycles previews. The industrial robot has six independent parts, painted metal, rubber joints, optical lenses, and embedded PBR textures. The course includes detailed decking, bridge, cargo, and finish assets. See [`unreal/README.md`](unreal/README.md) for regeneration and import instructions. The Unreal source includes corrected coordinate mapping and input handling, but remains uncompiled here; its SpacetimeDB bridge is an event interface and still needs a network transport. No skeletal animation or native multiplayer is claimed. The deployed Space includes the complete native handoff under [`native/`](native/).
 
 ## Develop and verify
 
@@ -71,5 +71,5 @@ npm run build
 python scripts/deploy.py "Deploy verified game build"
 ```
 
-The script uses existing Hugging Face credentials and uploads the static production build. SpacetimeDB Cloud provides persistence. No paid graphics server is required. An offline backend is visibly reported; no fake online players or local ranked results are substituted.
+The script uses existing Hugging Face credentials and uploads the static production build plus `native/` containing the Blender exports/source and Unreal project. The default target is `sankalphs/singularity1`; pass a second argument to target another Space. SpacetimeDB Cloud provides persistence. No paid graphics server is required. An offline backend is visibly reported; no fake online players or local ranked results are substituted.
 

native/README.md

@@ -0,0 +1,4 @@
+# Singularity native handoff
+
+This folder contains the Blender source/export and Unreal Engine 5.4 project.
+Run the Blender scripts first, then open `unreal/Singularity.uproject` in Unreal.

native/art/blender/build_realistic_assets.py

@@ -0,0 +1,277 @@
+"""Blender-only industrial art build, GLB exports, packed .blend and review renders.
+Run: blender --background --python art/blender/build_realistic_assets.py
+Blender coordinates: X lateral, Y course-forward, Z up, metres.
+"""
+from pathlib import Path
+import math
+import json
+import bpy
+import numpy as np
+from mathutils import Vector
+
+OUT = Path(__file__).resolve().parents[1] / 'generated'
+OUT.mkdir(parents=True, exist_ok=True)
+bpy.ops.object.select_all(action='SELECT')
+bpy.ops.object.delete(use_global=False)
+scene = bpy.context.scene
+scene.unit_settings.system = 'METRIC'
+scene.render.engine = 'CYCLES'
+scene.cycles.samples = 32
+scene.cycles.use_denoising = True
+scene.render.resolution_percentage = 100
+scene.world.color = (0.16, 0.16, 0.16)
+scene.view_settings.view_transform = 'AgX'
+rng = np.random.default_rng(19)
+
+def texture(name, base, rough=False):
+    size = 256
+    noise = rng.random((size, size))
+    scratches = rng.random((size, 1)) > .97
+    pixels = np.ones((size, size, 4), dtype=np.float32)
+    for channel in range(3):
+        pixels[:, :, channel] = np.clip(base[channel] * (.88 + .18 * noise) + scratches * .025, 0, 1)
+    img = bpy.data.images.new(name, width=size, height=size)
+    if rough:
+        img.colorspace_settings.name = 'Non-Color'
+    img.pixels.foreach_set(pixels.ravel())
+    img.pack()
+    return img
+
+def material(name, color, metal=0, roughness=.45, textured=False):
+    mat = bpy.data.materials.new(name)
+    mat.use_nodes = True
+    mat.diffuse_color = (*color, 1)
+    shader = mat.node_tree.nodes.get('Principled BSDF')
+    shader.inputs['Base Color'].default_value = (*color, 1)
+    shader.inputs['Metallic'].default_value = metal
+    shader.inputs['Roughness'].default_value = roughness
+    if textured:
+        for socket, image in [('Base Color', texture(name+'_color', color)),
+                              ('Roughness', texture(name+'_roughness', (roughness,)*3, True))]:
+            node = mat.node_tree.nodes.new('ShaderNodeTexImage')
+            node.image = image
+            mat.node_tree.links.new(node.outputs['Color'], shader.inputs[socket])
+    return mat
+
+coral = material('TeamCoral', (.48, .065, .025), .65, .32, True)
+mint = material('TeamMint', (.055, .38, .28), .6, .36, True)
+steel = material('BrushedTitanium', (.31, .36, .40), .85, .3, True)
+dark = material('GraphiteCeramic', (.028, .04, .052), .65, .34, True)
+rubber = material('JointRubber', (.012, .016, .018), .05, .78, True)
+deck = material('WeatheredDeck', (.25, .29, .3), .7, .57, True)
+gold = material('SafetyOchre', (.65, .34, .035), .5, .42, True)
+glass = material('OpticalGlass', (.012, .052, .068), .8, .12)
+white = material('MarkingIvory', (.78, .81, .75), .05, .42)
+lightmat = material('StatusLED', (.09, .7, .51), .3, .2)
+bsdf = lightmat.node_tree.nodes.get('Principled BSDF')
+bsdf.inputs['Emission Color'].default_value = (.1, 1, .66, 1)
+bsdf.inputs['Emission Strength'].default_value = 3
+
+def box(name, pos, size, mat, bevel=.025):
+    bpy.ops.mesh.primitive_cube_add(size=1, location=pos)
+    obj = bpy.context.object
+    obj.name = name
+    obj.scale = size
+    bpy.ops.object.transform_apply(location=False, rotation=False, scale=True)
+    obj.data.materials.append(mat)
+    if bevel:
+        mod = obj.modifiers.new('Machined edge radius', 'BEVEL')
+        mod.width = bevel
+        mod.segments = 3
+        mod = obj.modifiers.new('Weighted corner normals', 'WEIGHTED_NORMAL')
+    return obj
+
+def ball(name, pos, size, mat):
+    bpy.ops.mesh.primitive_uv_sphere_add(segments=24, ring_count=12, location=pos)
+    obj = bpy.context.object
+    obj.name = name
+    obj.scale = size
+    bpy.ops.object.transform_apply(location=False, rotation=False, scale=True)
+    obj.data.materials.append(mat)
+    for poly in obj.data.polygons:
+        poly.use_smooth = True
+    return obj
+
+def rod(name, a, b, radius, mat, vertices=16):
+    a, b = Vector(a), Vector(b)
+    bpy.ops.mesh.primitive_cylinder_add(vertices=vertices, radius=radius, depth=(b-a).length, location=(a+b)/2)
+    obj = bpy.context.object
+    obj.name = name
+    obj.rotation_mode = 'QUATERNION'
+    obj.rotation_quaternion = (b-a).to_track_quat('Z', 'Y')
+    obj.data.materials.append(mat)
+    bevel = obj.modifiers.new('Turned edge', 'BEVEL')
+    bevel.width = min(.008, radius*.2)
+    bevel.segments = 2
+    return obj
+
+def label(text, pos, size, mat=white):
+    bpy.ops.object.text_add(location=pos, rotation=(math.pi/2, 0, math.pi))
+    obj = bpy.context.object
+    obj.data.body = text
+    obj.data.align_x = 'CENTER'
+    obj.data.size = size
+    obj.data.extrude = .001
+    obj.data.materials.append(mat)
+    bpy.ops.object.convert(target='MESH')
+    return bpy.context.object
+
+def group_since(before, name):
+    objects = [o for o in scene.objects if o not in before and o.type == 'MESH']
+    collection = bpy.data.collections.new(name)
+    scene.collection.children.link(collection)
+    for obj in objects:
+        for old in list(obj.users_collection):
+            old.objects.unlink(obj)
+        collection.objects.link(obj)
+    return objects
+
+def export(name, objects):
+    bpy.ops.object.select_all(action='DESELECT')
+    for obj in objects:
+        obj.select_set(True)
+    bpy.context.view_layer.objects.active = objects[0]
+    bpy.ops.export_scene.gltf(filepath=str(OUT/name), export_format='GLB', use_selection=True,
+                             export_apply=True, export_animations=False, export_extras=True)
+
+body_start = set(scene.objects)
+roles = [('EyesHead',(0,0,3)), ('LeftArm',(-1,0,2)), ('RightArm',(1,0,2)),
+         ('TorsoBack',(0,0,2)), ('LeftLeg',(-.45,0,.35)), ('RightLeg',(.45,0,.35))]
+for role, center in roles:
+    before = set(scene.objects)
+    x,y,z = center
+    if role == 'EyesHead':
+        ball('Helmet shell', center, (.4,.32,.42), coral)
+        box('Visor surround', (0,.27,3.02), (.66,.14,.23), dark, .07)
+        for side in [-1,1]:
+            rod('Optical housing',(side*.18,.32,3.02),(side*.18,.40,3.02),.096,steel,32)
+            rod('Optical lens',(side*.18,.401,3.02),(side*.18,.413,3.02),.074,glass,32)
+            ball('Sensor LED',(side*.27,.35,2.98),(.017,.015,.017),lightmat)
+        box('Brow plate',(0,.24,3.27),(.49,.18,.065),steel)
+    elif role == 'TorsoBack':
+        box('Pressure hull',center,(.82,.54,.94),dark,.13)
+        box('Chest armour',(0,.29,2.08),(.71,.14,.68),coral,.075)
+        label('S / 06',(0,.37,2.07),.13)
+        for i in range(5):
+            box('Intake louvre',(-.21+i*.105,.375,1.86),(.057,.035,.10),rubber,.008)
+        for side in [-1,1]:
+            rod('Back power canister',(side*.25,-.3,1.68),(side*.25,-.3,2.35),.105,steel)
+            rod('Shoulder coupler',(side*.38,0,2.2),(side*.75,0,2.1),.105,rubber)
+            rod('Hip actuator',(side*.22,0,1.62),(side*.42,0,.67),.09,steel)
+        rod('Neck',(0,0,2.43),(0,0,2.72),.13,rubber)
+    elif 'Arm' in role:
+        box('Forearm housing',center,(.29,.33,.54),coral,.075)
+        ball('Universal wrist',(x,0,1.68),(.15,.16,.13),rubber)
+        box('Palm',(x,.05,1.49),(.25,.19,.23),dark,.045)
+        for finger in [-1,0,1]:
+            box('Gripper finger',(x+finger*.085,.12,1.30),(.065,.15,.19),steel,.025)
+        for i in range(4):
+            box('Cooling rib',(x,0,2.17+i*.034),(.30,.34,.013),rubber,.004)
+    else:
+        box('Ankle armour',(x,0,.5),(.29,.34,.37),coral,.05)
+        box('Boot',(x,.13,.22),(.38,.64,.27),dark,.065)
+        box('Toe guard',(x,.37,.26),(.35,.15,.16),steel,.03)
+        for i in range(6):
+            box('Sole tread',(x,-.12+i*.09,.075),(.39,.048,.055),rubber,.008)
+    for side in [-1,1]:
+        rod('Hex fastener',(x+side*.10,.18,z+.12),(x+side*.10,.20,z+.12),.027,steel,6)
+    objects = [o for o in scene.objects if o not in before]
+    # Each exported role is one multi-material mesh with its pivot at the solver node.
+    bpy.ops.object.select_all(action='DESELECT')
+    for obj in objects:
+        obj.select_set(True)
+        bpy.context.view_layer.objects.active=obj
+        bpy.ops.object.convert(target='MESH')
+    bpy.context.view_layer.objects.active=objects[0]
+    bpy.ops.object.join()
+    obj=bpy.context.object
+    obj.name=role
+    scene.cursor.location=center
+    bpy.ops.object.origin_set(type='ORIGIN_CURSOR')
+    obj['singularity_role']=role
+body = group_since(body_start,'SingularityBody')
+export('singularity_body.glb',body)
+
+before=set(scene.objects)
+for start,end in [(-5,7),(15,27),(27,47)]:
+    box('Structural platform',(0,(start+end)/2,-.34),(9.2,end-start,.64),dark,.09)
+    for yy in np.arange(start+.5,end,1):
+        for xx in [-3.45,-1.15,1.15,3.45]:
+            box('Deck panel',(xx,float(yy),.005),(2.25,.95,.10),deck,.018)
+            for dx in [-1,1]:
+                rod('Deck rivet',(xx+dx, float(yy)-.32,.056),(xx+dx,float(yy)-.32,.064),.035,steel,6)
+        for xx in [-4.5,4.5]:
+            box('Edge beacon',(xx,float(yy),.095),(.045,.52,.025),lightmat,.005)
+    for xx in [-4.65,4.65]:
+        box('Perimeter beam',(xx,(start+end)/2,-.22),(.17,end-start,.22),steel)
+for yy in np.arange(7.15,15,.30):
+    box('Bridge plank',(0,float(yy),0),(2.58,.27,.12),steel,.018)
+for xx in [-1.15,1.15]:
+    rod('Bridge cable',(xx,7,-.1),(xx,15,-.1),.045,dark)
+for yy in [6.4,15.5,27.5,41.4]:
+    for xx in np.arange(-4.2,4.3,.6):
+        box('Hazard stripe',(float(xx),yy,.071),(.30,.35,.008),gold,.002)
+box('Delivery inset',(0,26,.07),(4.8,2.6,.025),mint)
+delivery_label=label('02 / CARGO',(0,24.6,.095),.32)
+delivery_label.rotation_euler=(0,0,math.pi)
+course=group_since(before,'CourseModules')
+export('course_modules.glb',course)
+
+before=set(scene.objects)
+box('Cargo shell',(0,18,.54),(.9,.9,.9),gold,.065)
+for x in [-.43,.43]:
+    for y in [17.57,18.43]:
+        box('Cargo bumper',(x,y,.54),(.13,.13,.98),rubber,.025)
+for z in [.14,.90]:
+    box('Cargo band',(0,18,z),(.94,.94,.07),steel)
+label('CARGO',(0,18.456,.58),.13,dark)
+for x in [-3.8,3.8]:
+    box('Finish pillar',(x,42,2.8),(.32,.5,5.6),dark,.055)
+    box('Finish light',(x,42.27,2.8),(.07,.035,5.2),lightmat,.012)
+box('Finish crossbeam',(0,42,5.6),(8.2,.5,.6),steel,.07)
+label('S I N G U L A R I T Y',(0,42.26,5.51),.26,dark)
+rod('Sweeper mast',(0,34,.1),(0,34,2.8),.11,dark)
+box('Sweeper arm',(0,34,1.5),(7.2,.24,.27),gold,.06)
+finish=group_since(before,'CargoAndFinish')
+export('cargo_and_finish.glb',finish)
+
+def area(name,pos,power,size,color):
+    bpy.ops.object.light_add(type='AREA',location=pos)
+    obj=bpy.context.object
+    obj.name=name
+    obj.data.energy=power
+    obj.data.shape='DISK'
+    obj.data.size=size
+    obj.data.color=color
+    obj.rotation_euler=(Vector((0,0,1.6))-obj.location).to_track_quat('-Z','Y').to_euler()
+area('Warm key',(3,4,8),1800,5,(1,.83,.67))
+area('Cool rim',(-4,-3,6),2200,4,(.57,.75,1))
+area('Soft fill',(-3,4,3),900,4,(.8,.93,1))
+bpy.ops.object.light_add(type='SUN',rotation=(.4,-.5,-.5))
+bpy.context.object.data.energy=2
+bpy.context.object.data.angle=.15
+bpy.ops.object.camera_add()
+camera=bpy.context.object
+scene.camera=camera
+def shot(name,pos,target,lens,width,height):
+    camera.location=pos
+    camera.rotation_euler=(Vector(target)-camera.location).to_track_quat('-Z','Y').to_euler()
+    camera.data.lens=lens
+    scene.render.resolution_x=width
+    scene.render.resolution_y=height
+    scene.render.filepath=str(OUT/name)
+    bpy.ops.render.render(write_still=True)
+
+manifest={'units':'metres','axes':'Blender X lateral, Y forward, Z up',
+          'roles':[r for r,_ in roles], 'role_pivots':dict(roles),
+          'exports':['singularity_body.glb','course_modules.glb','cargo_and_finish.glb'],
+          'materials':[m.name for m in bpy.data.materials],
+          'mesh_objects':len([o for o in scene.objects if o.type=='MESH'])}
+(OUT/'asset-manifest.json').write_text(json.dumps(manifest,indent=2))
+shot('body-preview.png',(4.5,7,3.6),(0,0,1.65),58,1100,1100)
+camera.data.type='ORTHO'
+camera.data.ortho_scale=64
+shot('course-preview.png',(36,60,35),(0,21,0),46,1600,1000)
+bpy.context.preferences.filepaths.save_version=0
+bpy.ops.wm.save_as_mainfile(filepath=str(OUT/'singularity-art.blend'))
+print('ASSET_BUILD_COMPLETE',OUT)

native/art/blender/generate_singularity_assets.py

@@ -0,0 +1,5 @@
+"""Compatibility entry point for the Blender industrial asset builder."""
+from pathlib import Path
+import runpy
+
+runpy.run_path(str(Path(__file__).with_name("build_realistic_assets.py")), run_name="__main__")

native/art/blender/verify_assets.py

@@ -0,0 +1,23 @@
+"""Round-trip generated GLBs through Blender, checking real geometry and textures."""
+from pathlib import Path
+import bpy
+
+root=Path(__file__).resolve().parents[1]/'generated'
+for name in ['singularity_body.glb','course_modules.glb','cargo_and_finish.glb']:
+    bpy.ops.object.select_all(action='SELECT')
+    bpy.ops.object.delete(use_global=False)
+    bpy.ops.import_scene.gltf(filepath=str(root/name))
+    meshes=[o for o in bpy.context.scene.objects if o.type=='MESH']
+    assert meshes, name
+    for obj in meshes:
+        assert len(obj.data.polygons)>0, obj.name
+        assert obj.data.uv_layers, obj.name
+    if name=='singularity_body.glb':
+        assert {o.name for o in meshes}=={'EyesHead','LeftArm','RightArm','TorsoBack','LeftLeg','RightLeg'}
+        for obj in meshes:
+            assert len(obj.data.materials)>=4, obj.name
+    textures=[n.image for obj in meshes for mat in obj.data.materials if mat and mat.use_nodes
+              for n in mat.node_tree.nodes if n.type=='TEX_IMAGE' and n.image]
+    assert textures and all(img.size[0]>0 for img in textures), name
+    print('ROUND_TRIP_OK',name,len(meshes),'meshes',len(textures),'texture references')
+print('ALL_ASSETS_VERIFIED')

native/art/generated/asset-manifest.json

@@ -0,0 +1,64 @@
+{
+  "units": "metres",
+  "axes": "Blender X lateral, Y forward, Z up",
+  "roles": [
+    "EyesHead",
+    "LeftArm",
+    "RightArm",
+    "TorsoBack",
+    "LeftLeg",
+    "RightLeg"
+  ],
+  "role_pivots": {
+    "EyesHead": [
+      0,
+      0,
+      3
+    ],
+    "LeftArm": [
+      -1,
+      0,
+      2
+    ],
+    "RightArm": [
+      1,
+      0,
+      2
+    ],
+    "TorsoBack": [
+      0,
+      0,
+      2
+    ],
+    "LeftLeg": [
+      -0.45,
+      0,
+      0.35
+    ],
+    "RightLeg": [
+      0.45,
+      0,
+      0.35
+    ]
+  },
+  "exports": [
+    "singularity_body.glb",
+    "course_modules.glb",
+    "cargo_and_finish.glb"
+  ],
+  "materials": [
+    "BrushedTitanium",
+    "Dots Stroke",
+    "GraphiteCeramic",
+    "JointRubber",
+    "MarkingIvory",
+    "Material",
+    "OpticalGlass",
+    "SafetyOchre",
+    "StatusLED",
+    "TeamCoral",
+    "TeamMint",
+    "WeatheredDeck"
+  ],
+  "mesh_objects": 738
+}

native/art/generated/cargo_and_finish.glb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e7a70da39aff7cde9b8a050c74661e547f852973cec4fcc7c6e60670b932fbcf
+size 839048

native/art/generated/course_modules.glb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d01d13cf500accf3cfa7c5ab855b15b691502d81e41ffdbb81ee1394a5642559
+size 8064152

native/art/generated/singularity-art.blend

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2703c45ff18cf877bcebe347737885d119eb87577646b70358eb502ae363df39
+size 7799645

native/art/generated/singularity_body.glb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cb8d625563924d2d2fb47854f2775a3aa723fca89fcb3ec6264ddea08eb05fa7
+size 1449444

native/singularity-native-handoff.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fb2cb0023cd889108621fd5c3166eb7cd5a495a624f75503868e668e45d7a7e9
+size 7423317

native/unreal/Config/DefaultEngine.ini

@@ -0,0 +1,8 @@
+[/Script/EngineSettings.GameMapsSettings]
+GameDefaultMap=/Game/Singularity/Maps/Lobby
+EditorStartupMap=/Game/Singularity/Maps/Lobby
+GlobalDefaultGameMode=/Script/Singularity.SingularityGameMode
+
+[/Script/OnlineSubsystemUtils.IpNetDriver]
+NetServerMaxTickRate=60
+MaxClientRate=100000

native/unreal/Config/DefaultInput.ini

@@ -0,0 +1,6 @@
+[/Script/Engine.InputSettings]
++AxisMappings=(AxisName="Singularity_MoveX",Key=A,Scale=-1.0)
++AxisMappings=(AxisName="Singularity_MoveX",Key=D,Scale=1.0)
++AxisMappings=(AxisName="Singularity_MoveZ",Key=S,Scale=-1.0)
++AxisMappings=(AxisName="Singularity_MoveZ",Key=W,Scale=1.0)
++ActionMappings=(ActionName="Singularity_Action",Key=SpaceBar)

native/unreal/README.md

@@ -0,0 +1,32 @@
+# Unreal / Blender handoff
+
+The generated art is ready in `../art/generated/`: three GLBs with embedded PBR textures, a packed `singularity-art.blend`, and two Cycles preview renders. All art was built and rendered in Blender 4.5.9; no external asset downloads or AI images are used.
+
+## Open the artwork
+
+Open `../art/generated/singularity-art.blend` in Blender. Collections separate the six-part robot, deck/bridge, and cargo/finish/sweeper. The robot uses painted metal armour, machined fasteners, optical lenses, rubber joints, grippers, and treaded boots. Texture images are packed into the blend and embedded in each GLB. These are rigid meshes, not a skeletal character or animation montage.
+
+Regenerate with:
+```powershell
+& '../.tools/blender-4.5.9-windows-x64/blender.exe' --background --python ../art/blender/generate_singularity_assets.py
+& '../.tools/blender-4.5.9-windows-x64/blender.exe' --background --python ../art/blender/verify_assets.py
+```
+Commands above run from `unreal/`. Any Blender 4.5 installation may replace the portable executable path.
+
+## Unreal setup (requires editor verification)
+
+Build the supplied game/editor targets in Unreal 5.4, then create a level at `/Game/Singularity/Maps/Lobby`. That configured level is not yet supplied as a .umap. Import the three GLBs using scene import so course object transforms are retained. Keep body meshes separate, retain their local pivots, and enable material/texture import. Add simple collision for any meshes you wish to simulate.
+
+Create a Blueprint subclass of `ASingularitySharedBody`. Assign `RoleMeshes` in order: EyesHead, LeftArm, RightArm, TorsoBack, LeftLeg, RightLeg. Meshes are local to their solver node; keep the component scale at one after the importer converts metres to centimetres. TeamMaterial overrides only named TeamCoral/TeamMint paint slots, preserving rubber, steel, and optics.
+
+Server coordinates are metres: lateral X, up Y, forward Z. `ApplyAuthoritativeSnapshot` maps them to Unreal centimetres as `(Z, X, Y) * 100` and maps torso-first node order into role order. Ranked presentation is kinematic. Explicitly enabling Chaos on the parts is an experimental local preview; it is not the ranked simulation. Constraints have midpoint anchors and angular limits; local inputs expire after 500 ms and a hop requires a grounded press.
+
+## Networking boundary
+
+`USingularitySpacetimeBridge` is an event interface, not a connected SpacetimeDB client. A transport still needs authentication, subscriptions, JSON decoding, role leases, room/result handling, and reducer calls. The actual server join role is a numeric 0–5; input reducer payload is x/z/action. ClientTick and Role in the local packet are routing metadata, not additional input reducer arguments.
+
+Bind the player's bridge OnInputReady to the transport's input reducer, and feed decoded team snapshots into OnSnapshotReady / ApplyAuthoritativeSnapshot. Do not bind local force inputs to the ranked body. The controller uses WASD/Space at up to 30 Hz through DefaultInput.ini. The GameMode creates its bridge before BeginPlay; remote native clients own a local controller bridge.
+
+## Verification limits
+
+The exported files pass binary GLB tests and a Blender import round trip. Preview renders were visually inspected. Unreal is not installed in this environment: C++ compilation, import orientation, collision, Blueprint wiring, and native multiplayer remain unverified. The web build does not validate Unreal code.

native/unreal/Singularity.uproject

@@ -0,0 +1,8 @@
+{
+  "FileVersion": 3,
+  "EngineAssociation": "5.4",
+  "Category": "Games",
+  "Description": "Singularity shared-body competitive physics game",
+  "Modules": [{"Name":"Singularity","Type":"Runtime","LoadingPhase":"Default"}],
+  "Plugins": [{"Name":"EnhancedInput","Enabled":true},{"Name":"OnlineSubsystem","Enabled":true}]
+}

native/unreal/Source/Singularity.Target.cs

@@ -0,0 +1,13 @@
+using UnrealBuildTool;
+using System.Collections.Generic;
+
+public class SingularityTarget : TargetRules
+{
+    public SingularityTarget(TargetInfo Target) : base(Target)
+    {
+        Type = TargetType.Game;
+        DefaultBuildSettings = BuildSettingsVersion.V5;
+        IncludeOrderVersion = EngineIncludeOrderVersion.Unreal5_4;
+        ExtraModuleNames.Add("Singularity");
+    }
+}

native/unreal/Source/Singularity/Singularity.Build.cs

@@ -0,0 +1,9 @@
+using UnrealBuildTool;
+public class Singularity : ModuleRules
+{
+    public Singularity(ReadOnlyTargetRules Target) : base(Target)
+    {
+        PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
+        PublicDependencyModuleNames.AddRange(new[] { "Core", "CoreUObject", "Engine", "PhysicsCore", "EnhancedInput", "OnlineSubsystemUtils" });
+    }
+}

native/unreal/Source/Singularity/Singularity.cpp

@@ -0,0 +1,2 @@
+#include "Modules/ModuleManager.h"
+IMPLEMENT_PRIMARY_GAME_MODULE(FDefaultGameModuleImpl, Singularity, "Singularity");

native/unreal/Source/Singularity/SingularityGameMode.cpp

@@ -0,0 +1,19 @@
+#include "SingularityGameMode.h"
+#include "SingularitySharedBody.h"
+#include "SingularitySpacetimeBridge.h"
+#include "SingularityRolePlayerController.h"
+
+ASingularityGameMode::ASingularityGameMode()
+{
+    PrimaryActorTick.bCanEverTick = false;
+    SharedBodyClass = ASingularitySharedBody::StaticClass();
+    PlayerControllerClass = ASingularityRolePlayerController::StaticClass();
+}
+
+void ASingularityGameMode::StartPlay()
+{
+    // The bridge is intentionally transport-agnostic. A Blueprint or an
+    // Unreal SpacetimeDB plugin binds its events to this single game object.
+    SpacetimeBridge = NewObject<USingularitySpacetimeBridge>(this);
+    Super::StartPlay();
+}

native/unreal/Source/Singularity/SingularityGameMode.h

@@ -0,0 +1,25 @@
+#pragma once
+#include "CoreMinimal.h"
+#include "GameFramework/GameModeBase.h"
+#include "SingularityRoleTypes.h"
+#include "SingularityGameMode.generated.h"
+
+class ASingularitySharedBody;
+class USingularitySpacetimeBridge;
+class ASingularityRolePlayerController;
+
+UCLASS()
+class SINGULARITY_API ASingularityGameMode : public AGameModeBase
+{
+    GENERATED_BODY()
+public:
+    ASingularityGameMode();
+
+    virtual void StartPlay() override;
+
+    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Singularity")
+    TSubclassOf<ASingularitySharedBody> SharedBodyClass;
+
+    UPROPERTY(BlueprintReadOnly, Category = "Singularity")
+    TObjectPtr<USingularitySpacetimeBridge> SpacetimeBridge;
+};

native/unreal/Source/Singularity/SingularityRolePlayerController.cpp

@@ -0,0 +1,69 @@
+#include "SingularityRolePlayerController.h"
+
+#include "Components/InputComponent.h"
+#include "Engine/World.h"
+#include "SingularityGameMode.h"
+#include "SingularitySpacetimeBridge.h"
+
+ASingularityRolePlayerController::ASingularityRolePlayerController()
+{
+    PrimaryActorTick.bCanEverTick = true;
+}
+
+void ASingularityRolePlayerController::BeginPlay()
+{
+    Super::BeginPlay();
+    if (const ASingularityGameMode* Mode = GetWorld()->GetAuthGameMode<ASingularityGameMode>())
+    {
+        SpacetimeBridge = Mode->SpacetimeBridge;
+    }
+    if (!SpacetimeBridge)
+    {
+        // Clients do not own an authoritative GameMode, so they get a local
+        // bridge instance that their transport adapter can bind to.
+        SpacetimeBridge = NewObject<USingularitySpacetimeBridge>(this);
+    }
+}
+
+void ASingularityRolePlayerController::SetupInputComponent()
+{
+    Super::SetupInputComponent();
+    check(InputComponent);
+    InputComponent->BindAxis(TEXT("Singularity_MoveX"), this, &ASingularityRolePlayerController::HandleMoveX);
+    InputComponent->BindAxis(TEXT("Singularity_MoveZ"), this, &ASingularityRolePlayerController::HandleMoveZ);
+    InputComponent->BindAction(TEXT("Singularity_Action"), IE_Pressed, this, &ASingularityRolePlayerController::HandleActionPressed);
+    InputComponent->BindAction(TEXT("Singularity_Action"), IE_Released, this, &ASingularityRolePlayerController::HandleActionReleased);
+}
+
+void ASingularityRolePlayerController::Tick(float DeltaSeconds)
+{
+    Super::Tick(DeltaSeconds);
+    if (!IsLocalController()) return;
+    SendAccumulator += DeltaSeconds;
+    if (SpacetimeBridge && SendAccumulator >= (1.0f / 30.0f))
+    {
+        SendAccumulator = 0.0f;
+        ++ClientTick;
+        SpacetimeBridge->SubmitRoleInput(ControlledRole, MoveX, MoveZ, bAction, ClientTick);
+    }
+}
+
+void ASingularityRolePlayerController::HandleMoveX(float Value)
+{
+    MoveX = FMath::Clamp(Value, -1.0f, 1.0f);
+}
+
+void ASingularityRolePlayerController::HandleMoveZ(float Value)
+{
+    MoveZ = FMath::Clamp(Value, -1.0f, 1.0f);
+}
+
+void ASingularityRolePlayerController::HandleActionPressed()
+{
+    bAction = true;
+}
+
+void ASingularityRolePlayerController::HandleActionReleased()
+{
+    bAction = false;
+}

native/unreal/Source/Singularity/SingularityRolePlayerController.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "GameFramework/PlayerController.h"
+#include "SingularityRoleTypes.h"
+#include "SingularityRolePlayerController.generated.h"
+
+class USingularitySpacetimeBridge;
+
+/** Sends only the local role's bounded input to the shared bridge. */
+UCLASS()
+class SINGULARITY_API ASingularityRolePlayerController : public APlayerController
+{
+    GENERATED_BODY()
+
+public:
+    ASingularityRolePlayerController();
+
+    virtual void BeginPlay() override;
+    virtual void SetupInputComponent() override;
+    virtual void Tick(float DeltaSeconds) override;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Singularity|Role")
+    ESingularityBodyRole ControlledRole = ESingularityBodyRole::EyesHead;
+
+    UPROPERTY(BlueprintReadOnly, Category = "Singularity|Role")
+    TObjectPtr<USingularitySpacetimeBridge> SpacetimeBridge;
+
+private:
+    float MoveX = 0.0f;
+    float MoveZ = 0.0f;
+    bool bAction = false;
+    int64 ClientTick = 0;
+    float SendAccumulator = 0.0f;
+
+    void HandleMoveX(float Value);
+    void HandleMoveZ(float Value);
+    void HandleActionPressed();
+    void HandleActionReleased();
+};

native/unreal/Source/Singularity/SingularityRoleTypes.h

@@ -0,0 +1,65 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "SingularityRoleTypes.generated.h"
+
+UENUM(BlueprintType)
+enum class ESingularityBodyRole : uint8
+{
+    EyesHead,
+    LeftArm,
+    RightArm,
+    TorsoBack,
+    LeftLeg,
+    RightLeg
+};
+
+USTRUCT(BlueprintType)
+struct SINGULARITY_API FSingularityRoleInput
+{
+    GENERATED_BODY()
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite)
+    ESingularityBodyRole Role = ESingularityBodyRole::EyesHead;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite)
+    float X = 0.0f;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite)
+    float Z = 0.0f;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite)
+    bool bAction = false;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite)
+    int64 ClientTick = 0;
+};
+
+USTRUCT(BlueprintType)
+struct SINGULARITY_API FSingularityTeamSnapshot
+{
+    GENERATED_BODY()
+
+    // The server sends the six physics nodes in shared/physics.ts order:
+    // torso, head, left arm, right arm, left leg, right leg.
+    UPROPERTY(EditAnywhere, BlueprintReadWrite)
+    TArray<FVector> Nodes;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite)
+    int32 CheckpointStage = 0;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite)
+    int32 Falls = 0;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite)
+    int64 ServerTick = 0;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite)
+    int64 FinishTimeMs = 0;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite)
+    bool bDelivered = false;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite)
+    bool bFinished = false;
+};

native/unreal/Source/Singularity/SingularitySharedBody.cpp

@@ -0,0 +1,191 @@
+#include "SingularitySharedBody.h"
+
+#include "Components/SceneComponent.h"
+#include "Components/StaticMeshComponent.h"
+#include "Engine/World.h"
+#include "Engine/StaticMesh.h"
+#include "Materials/MaterialInterface.h"
+#include "PhysicsEngine/PhysicsConstraintComponent.h"
+
+namespace
+{
+const FName RoleNames[] = {
+    TEXT("EyesHead"), TEXT("LeftArm"), TEXT("RightArm"),
+    TEXT("TorsoBack"), TEXT("LeftLeg"), TEXT("RightLeg")};
+}
+
+ASingularitySharedBody::ASingularitySharedBody()
+{
+    PrimaryActorTick.bCanEverTick = true;
+
+    BodyRoot = CreateDefaultSubobject<USceneComponent>(TEXT("BodyRoot"));
+    RootComponent = BodyRoot;
+
+    for (int32 Index = 0; Index < UE_ARRAY_COUNT(RoleNames); ++Index)
+    {
+        UStaticMeshComponent* Part = CreateDefaultSubobject<UStaticMeshComponent>(RoleNames[Index]);
+        Part->SetupAttachment(BodyRoot);
+        // Ranked presentation follows server snapshots, never local Chaos forces.
+        Part->SetSimulatePhysics(false);
+        const FVector Rest[] = {FVector(0,0,300), FVector(0,-100,200),
+            FVector(0,100,200), FVector(0,0,200), FVector(0,-45,35), FVector(0,45,35)};
+        Part->SetRelativeLocation(Rest[Index]);
+        Part->SetEnableGravity(true);
+        Part->SetCollisionProfileName(TEXT("PhysicsActor"));
+        RoleBodies.Add(Part);
+        CurrentInputs.Add(FSingularityRoleInput());
+        InputAge.Add(1.0f);
+        PreviousAction.Add(false);
+    }
+
+    const FName ConstraintNames[] = {
+        TEXT("ConstraintTorsoHead"), TEXT("ConstraintTorsoLeftArm"),
+        TEXT("ConstraintTorsoRightArm"), TEXT("ConstraintTorsoLeftLeg"),
+        TEXT("ConstraintTorsoRightLeg"), TEXT("ConstraintLegs"),
+        TEXT("ConstraintHeadLeftArm"), TEXT("ConstraintHeadRightArm")};
+    for (const FName& Name : ConstraintNames)
+    {
+        UPhysicsConstraintComponent* Constraint = CreateDefaultSubobject<UPhysicsConstraintComponent>(Name);
+        Constraint->SetupAttachment(BodyRoot);
+        Constraint->SetDisableCollision(true);
+        Constraints.Add(Constraint);
+    }
+}
+
+void ASingularitySharedBody::BeginPlay()
+{
+    Super::BeginPlay();
+    LoadImportedArt();
+    ConfigureConstraints();
+}
+
+void ASingularitySharedBody::LoadImportedArt()
+{
+    for (int32 Index = 0; Index < RoleBodies.Num(); ++Index)
+    {
+        if (RoleMeshes.IsValidIndex(Index))
+        {
+            if (UStaticMesh* Mesh = RoleMeshes[Index].LoadSynchronous())
+            {
+                RoleBodies[Index]->SetStaticMesh(Mesh);
+            }
+        }
+        if (UMaterialInterface* Material = TeamMaterial.LoadSynchronous())
+        {
+            for (int32 Slot = 0; Slot < RoleBodies[Index]->GetNumMaterials(); ++Slot)
+            {
+                const UMaterialInterface* Existing = RoleBodies[Index]->GetMaterial(Slot);
+                if (Existing && (Existing->GetName().Contains(TEXT("TeamCoral")) ||
+                    Existing->GetName().Contains(TEXT("TeamMint"))))
+                    RoleBodies[Index]->SetMaterial(Slot, Material);
+            }
+        }
+    }
+}
+
+void ASingularitySharedBody::ConfigureConstraints()
+{
+    if (RoleBodies.Num() != 6 || Constraints.Num() != 8)
+    {
+        return;
+    }
+
+    const int32 Pairs[][2] = {{3, 0}, {3, 1}, {3, 2}, {3, 4},
+                              {3, 5}, {4, 5}, {0, 1}, {0, 2}};
+    for (int32 Index = 0; Index < Constraints.Num(); ++Index)
+    {
+        const FVector A = RoleBodies[Pairs[Index][0]]->GetComponentLocation();
+        const FVector B = RoleBodies[Pairs[Index][1]]->GetComponentLocation();
+        Constraints[Index]->SetWorldLocation((A + B) * 0.5);
+        Constraints[Index]->SetLinearXLimit(LCM_Locked, 0);
+        Constraints[Index]->SetLinearYLimit(LCM_Locked, 0);
+        Constraints[Index]->SetLinearZLimit(LCM_Locked, 0);
+        Constraints[Index]->SetAngularSwing1Limit(ACM_Limited, 35);
+        Constraints[Index]->SetAngularSwing2Limit(ACM_Limited, 35);
+        Constraints[Index]->SetAngularTwistLimit(ACM_Limited, 25);
+        Constraints[Index]->SetConstrainedComponents(
+            RoleBodies[Pairs[Index][0]], NAME_None,
+            RoleBodies[Pairs[Index][1]], NAME_None);
+    }
+}
+
+void ASingularitySharedBody::Tick(float DeltaSeconds)
+{
+    Super::Tick(DeltaSeconds);
+
+    for (int32 Index = 0; Index < RoleBodies.Num(); ++Index)
+    {
+        const FSingularityRoleInput& Input = CurrentInputs[Index];
+        const ESingularityBodyRole Role = static_cast<ESingularityBodyRole>(Index);
+        InputAge[Index] += DeltaSeconds;
+        if (!RoleBodies[Index]->IsSimulatingPhysics()) continue;
+        if (InputAge[Index] > 0.5f) { PreviousAction[Index] = false; continue; }
+        const FVector Force(Input.Z * RoleForce, Input.X * RoleForce, 0.0f);
+        RoleBodies[Index]->AddForce(Force);
+        RoleBodies[Index]->AddTorqueInRadians(FVector(0.0f, Input.X * RoleForce * 0.08f, 0.0f));
+
+        FHitResult Ground;
+        const FVector Foot = RoleBodies[Index]->GetComponentLocation();
+        FCollisionQueryParams Query;
+        Query.AddIgnoredActor(this);
+        const bool bGrounded = GetWorld()->LineTraceSingleByChannel(
+            Ground, Foot, Foot - FVector(0,0,55), ECC_Visibility, Query);
+        if (Input.bAction && !PreviousAction[Index] && IsLeg(Role) && bGrounded)
+        {
+            RoleBodies[Index]->AddImpulse(FVector(0.0f, 0.0f, LegHopImpulse));
+        }
+
+        PreviousAction[Index] = Input.bAction;
+    }
+}
+
+void ASingularitySharedBody::ApplyRoleInput(ESingularityBodyRole Role, const FSingularityRoleInput& Input)
+{
+    const int32 Index = RoleIndex(Role);
+    if (CurrentInputs.IsValidIndex(Index))
+    {
+        if (!FMath::IsFinite(Input.X) || !FMath::IsFinite(Input.Z)) return;
+        InputAge[Index] = 0.0f;
+        CurrentInputs[Index] = Input;
+        CurrentInputs[Index].X = FMath::Clamp(CurrentInputs[Index].X, -1.0f, 1.0f);
+        CurrentInputs[Index].Z = FMath::Clamp(CurrentInputs[Index].Z, -1.0f, 1.0f);
+    }
+}
+
+void ASingularitySharedBody::ApplyRoleInputPacket(const FSingularityRoleInput& Input)
+{
+    ApplyRoleInput(Input.Role, Input);
+}
+
+void ASingularitySharedBody::ApplyAuthoritativeSnapshot(const FSingularityTeamSnapshot& Snapshot)
+{
+    if (Snapshot.Nodes.Num() != 6) return;
+    for (const FVector& Node : Snapshot.Nodes) if (Node.ContainsNaN()) return;
+    // SpacetimeDB's shared solver stores torso/head before the role list used
+    // by the Unreal actor. Keep this translation at the transport boundary.
+    const int32 NodeToRole[] = {3, 0, 1, 2, 4, 5};
+    for (int32 NodeIndex = 0; NodeIndex < Snapshot.Nodes.Num() && NodeIndex < UE_ARRAY_COUNT(NodeToRole); ++NodeIndex)
+    {
+        const int32 Role = NodeToRole[NodeIndex];
+        const FVector Node = Snapshot.Nodes[NodeIndex];
+        RoleBodies[Role]->SetSimulatePhysics(false);
+        RoleBodies[Role]->SetWorldLocation(GetActorTransform().TransformPosition(
+            FVector(Node.Z, Node.X, Node.Y) * 100.0));
+    }
+}
+
+UStaticMeshComponent* ASingularitySharedBody::GetRoleComponent(ESingularityBodyRole Role) const
+{
+    const int32 Index = RoleIndex(Role);
+    return RoleBodies.IsValidIndex(Index) ? RoleBodies[Index] : nullptr;
+}
+
+int32 ASingularitySharedBody::RoleIndex(ESingularityBodyRole Role)
+{
+    return static_cast<int32>(Role);
+}
+
+bool ASingularitySharedBody::IsLeg(ESingularityBodyRole Role)
+{
+    return Role == ESingularityBodyRole::LeftLeg || Role == ESingularityBodyRole::RightLeg;
+}

native/unreal/Source/Singularity/SingularitySharedBody.h

@@ -0,0 +1,69 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "GameFramework/Actor.h"
+#include "SingularityRoleTypes.h"
+#include "SingularitySharedBody.generated.h"
+
+class UPhysicsConstraintComponent;
+class UStaticMesh;
+class UStaticMeshComponent;
+class UMaterialInterface;
+
+/** A six-piece Chaos body that can be driven by six independent role leases. */
+UCLASS(Blueprintable)
+class SINGULARITY_API ASingularitySharedBody : public AActor
+{
+    GENERATED_BODY()
+
+public:
+    ASingularitySharedBody();
+
+    virtual void BeginPlay() override;
+    virtual void Tick(float DeltaSeconds) override;
+
+    UFUNCTION(BlueprintCallable, Category = "Singularity|Body")
+    void ApplyRoleInput(ESingularityBodyRole Role, const FSingularityRoleInput& Input);
+
+    UFUNCTION(BlueprintCallable, Category = "Singularity|Body")
+    void ApplyRoleInputPacket(const FSingularityRoleInput& Input);
+
+    UFUNCTION(BlueprintCallable, Category = "Singularity|Body")
+    void ApplyAuthoritativeSnapshot(const FSingularityTeamSnapshot& Snapshot);
+
+    UFUNCTION(BlueprintPure, Category = "Singularity|Body")
+    UStaticMeshComponent* GetRoleComponent(ESingularityBodyRole Role) const;
+
+    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Singularity|Body")
+    TObjectPtr<USceneComponent> BodyRoot;
+
+    // Order is the wire order: EyesHead, LeftArm, RightArm, TorsoBack, LeftLeg, RightLeg.
+    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Singularity|Body")
+    TArray<TObjectPtr<UStaticMeshComponent>> RoleBodies;
+
+    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Singularity|Body")
+    TArray<TObjectPtr<UPhysicsConstraintComponent>> Constraints;
+
+    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Singularity|Art")
+    TArray<TSoftObjectPtr<UStaticMesh>> RoleMeshes;
+
+    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Singularity|Art")
+    TSoftObjectPtr<UMaterialInterface> TeamMaterial;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Singularity|Physics")
+    float RoleForce = 120000.0f;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Singularity|Physics")
+    float LegHopImpulse = 350.0f;
+
+
+private:
+    TArray<float> InputAge;
+    TArray<bool> PreviousAction;
+    TArray<FSingularityRoleInput> CurrentInputs;
+
+    static int32 RoleIndex(ESingularityBodyRole Role);
+    static bool IsLeg(ESingularityBodyRole Role);
+    void LoadImportedArt();
+    void ConfigureConstraints();
+};

native/unreal/Source/Singularity/SingularitySpacetimeBridge.cpp

@@ -0,0 +1,41 @@
+#include "SingularitySpacetimeBridge.h"
+
+void USingularitySpacetimeBridge::SubmitRoleInput(
+    ESingularityBodyRole Role,
+    float X,
+    float Z,
+    bool bAction,
+    int64 ClientTick)
+{
+    FSingularityRoleInput Input;
+    if (static_cast<uint8>(Role) > 5 || !FMath::IsFinite(X) || !FMath::IsFinite(Z)) return;
+    Input.Role = Role;
+    Input.X = FMath::Clamp(X, -1.0f, 1.0f);
+    Input.Z = FMath::Clamp(Z, -1.0f, 1.0f);
+    Input.bAction = bAction;
+    Input.ClientTick = ClientTick;
+    OnInputReady.Broadcast(Input);
+}
+
+void USingularitySpacetimeBridge::ApplyTeamSnapshot(const FSingularityTeamSnapshot& Snapshot)
+{
+    if (Snapshot.Nodes.Num() != 6) return;
+    for (const FVector& Node : Snapshot.Nodes) if (Node.ContainsNaN()) return;
+    // Snapshots are server-owned. Consumers should apply only the six nodes
+    // and status fields supplied here; no client-side completion is accepted.
+    OnSnapshotReady.Broadcast(Snapshot);
+}
+
+FString USingularitySpacetimeBridge::RoleToWireName(ESingularityBodyRole Role)
+{
+    switch (Role)
+    {
+    case ESingularityBodyRole::EyesHead: return TEXT("0");
+    case ESingularityBodyRole::LeftArm: return TEXT("1");
+    case ESingularityBodyRole::RightArm: return TEXT("2");
+    case ESingularityBodyRole::TorsoBack: return TEXT("3");
+    case ESingularityBodyRole::LeftLeg: return TEXT("4");
+    case ESingularityBodyRole::RightLeg: return TEXT("5");
+    default: return TEXT("unknown");
+    }
+}

native/unreal/Source/Singularity/SingularitySpacetimeBridge.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "UObject/Object.h"
+#include "SingularityRoleTypes.h"
+#include "SingularitySpacetimeBridge.generated.h"
+
+DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FSingularityInputReady, const FSingularityRoleInput&, Input);
+DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FSingularitySnapshotReady, const FSingularityTeamSnapshot&, Snapshot);
+
+/**
+ * Small engine-side seam for the existing SpacetimeDB contract.
+ *
+ * The production browser client submits bounded x/z/action inputs and receives
+ * authoritative team snapshots. An Unreal transport can bind to these events
+ * without ever accepting a client pose, checkpoint, or finish time.
+ */
+UCLASS(BlueprintType)
+class SINGULARITY_API USingularitySpacetimeBridge : public UObject
+{
+    GENERATED_BODY()
+
+public:
+    UPROPERTY(BlueprintAssignable)
+    FSingularityInputReady OnInputReady;
+
+    UPROPERTY(BlueprintAssignable)
+    FSingularitySnapshotReady OnSnapshotReady;
+
+    UFUNCTION(BlueprintCallable, Category = "Singularity|Network")
+    void SubmitRoleInput(ESingularityBodyRole Role, float X, float Z, bool bAction, int64 ClientTick);
+
+    UFUNCTION(BlueprintCallable, Category = "Singularity|Network")
+    void ApplyTeamSnapshot(const FSingularityTeamSnapshot& Snapshot);
+
+    UFUNCTION(BlueprintPure, Category = "Singularity|Network")
+    static FString RoleToWireName(ESingularityBodyRole Role);
+};

native/unreal/Source/SingularityEditor.Target.cs

@@ -0,0 +1,13 @@
+using UnrealBuildTool;
+using System.Collections.Generic;
+
+public class SingularityEditorTarget : TargetRules
+{
+    public SingularityEditorTarget(TargetInfo Target) : base(Target)
+    {
+        Type = TargetType.Editor;
+        DefaultBuildSettings = BuildSettingsVersion.V5;
+        IncludeOrderVersion = EngineIncludeOrderVersion.Unreal5_4;
+        ExtraModuleNames.Add("Singularity");
+    }
+}