simready-forge 0.1.0__py3-none-any.whl

simready_forge/review.py

@@ -0,0 +1,167 @@
+"""The review of a saved asset: Isaac Sim's RTX renders and PhysX checks when Isaac Sim is installed, a software
+preview sheet when it is not."""
+
+import contextlib
+import json
+import os
+import subprocess
+import time
+from pathlib import Path
+
+import numpy as np
+
+SCRIPT = Path(__file__).with_name("isaac_review.py")
+PROBE = Path(__file__).with_name("isaac_probe.py")
+
+
+def find_isaac(explicit=None):
+    """Isaac Sim's Python: the argument, SIMREADY_FORGE_ISAAC, ISAACSIM_PYTHON, or a common install path."""
+    candidates = [explicit, os.environ.get("SIMREADY_FORGE_ISAAC"), os.environ.get("ISAACSIM_PYTHON")]
+    home = Path.home()
+    candidates += [
+        str(p)
+        for p in (
+            Path("D:/isaac/venv/Scripts/python.exe"),
+            Path("C:/isaac/venv/Scripts/python.exe"),
+            home / "isaacsim" / "python.bat",
+            home / "isaacsim" / "python.sh",
+            Path("/isaac-sim/python.sh"),
+        )
+    ]
+    for candidate in candidates:
+        if candidate and Path(candidate).is_file():
+            return str(candidate)
+    return None
+
+
+@contextlib.contextmanager
+def isaac_turn(wait=3600):
+    """One Isaac Sim review at a time on this machine: two at once can exhaust memory. The lock file holds the owner's
+    process id; one left by a process that has exited is taken over."""
+    lock = Path(os.environ.get("SIMREADY_FORGE_LOCK", Path.home() / ".simready-forge" / "isaac.lock"))
+    lock.parent.mkdir(parents=True, exist_ok=True)
+    deadline = time.monotonic() + wait
+    while True:
+        try:
+            fd = os.open(lock, os.O_CREAT | os.O_EXCL | os.O_WRONLY)
+            os.write(fd, str(os.getpid()).encode())
+            os.close(fd)
+            break
+        except FileExistsError:
+            if not _alive(lock):
+                lock.unlink(missing_ok=True)
+                continue
+            if time.monotonic() > deadline:
+                raise TimeoutError(f"another Isaac review still holds {lock}") from None
+            time.sleep(5)
+    try:
+        yield
+    finally:
+        lock.unlink(missing_ok=True)
+
+
+def _alive(lock):
+    try:
+        pid = int(lock.read_text(encoding="utf-8").strip() or 0)
+    except (OSError, ValueError):
+        return False
+    if pid <= 0:
+        return False
+    if os.name == "nt":
+        import ctypes
+
+        handle = ctypes.windll.kernel32.OpenProcess(0x1000, False, pid)  # PROCESS_QUERY_LIMITED_INFORMATION
+        if not handle:
+            return False
+        code = ctypes.c_ulong()
+        ctypes.windll.kernel32.GetExitCodeProcess(handle, ctypes.byref(code))
+        ctypes.windll.kernel32.CloseHandle(handle)
+        return code.value == 259  # STILL_ACTIVE
+    try:
+        os.kill(pid, 0)
+    except OSError:
+        return False
+    return True
+
+
+def review(asset, out_dir, isaac=None, timeout=1800):
+    """Review an asset into out_dir. Returns the report dict (review.json)."""
+    out = Path(out_dir)
+    out.mkdir(parents=True, exist_ok=True)
+    python = find_isaac(isaac)
+    if python is None:
+        return software_review(asset, out)
+    env = {k: v for k, v in os.environ.items() if k not in ("PYTHONPATH", "PYTHONHOME")}
+    env["OMNI_KIT_ACCEPT_EULA"] = "YES"
+    command = [python, str(SCRIPT), str(Path(asset).resolve()), str(out.resolve())]
+    with isaac_turn(), (out / "isaac.log").open("w", encoding="utf-8") as log:
+        code = subprocess.run(  # noqa: S603 (our own interpreter and script paths)
+            command,
+            env=env,
+            stdout=log,
+            stderr=subprocess.STDOUT,
+            timeout=timeout,
+            check=False,
+        ).returncode
+    report_file = out / "review.json"
+    report = json.loads(report_file.read_text(encoding="utf-8")) if report_file.is_file() else {}
+    report.update({"renderer": "isaac", "exit_code": code, "log": str(out / "isaac.log")})
+    if code == 2 or not report_file.is_file():
+        report["error"] = "the Isaac review crashed: see the log"
+    report_file.write_text(json.dumps(report, indent=1), encoding="utf-8")
+    return report
+
+
+def probe(asset, out_dir, isaac=None, timeout=3600, tests=()):
+    """Probe an asset's physics in Isaac Sim (isaac_probe.py): settle, tilt, push, lift, load, or only the named
+    `tests`, kept beside the others' earlier results. Returns the report dict (probe.json), or one with an error when
+    Isaac Sim is missing or the probe crashed."""
+    out = Path(out_dir)
+    out.mkdir(parents=True, exist_ok=True)
+    python = find_isaac(isaac)
+    if python is None:
+        return {"asset": str(asset), "error": "the probe needs Isaac Sim"}
+    env = {k: v for k, v in os.environ.items() if k not in ("PYTHONPATH", "PYTHONHOME")}
+    env["OMNI_KIT_ACCEPT_EULA"] = "YES"
+    command = [python, str(PROBE), str(Path(asset).resolve()), str(out.resolve()), *tests]
+    with isaac_turn(), (out / "isaac_probe.log").open("w", encoding="utf-8") as log:
+        code = subprocess.run(  # noqa: S603 (our own interpreter and script paths)
+            command, env=env, stdout=log, stderr=subprocess.STDOUT, timeout=timeout, check=False
+        ).returncode
+    report_file = out / "probe.json"
+    report = json.loads(report_file.read_text(encoding="utf-8")) if report_file.is_file() else {}
+    report.update({"exit_code": code, "log": str(out / "isaac_probe.log")})
+    if code == 2 or not report_file.is_file():
+        report["error"] = "the Isaac probe crashed: see the log"
+    report_file.write_text(json.dumps(report, indent=1), encoding="utf-8")
+    return report
+
+
+def software_review(asset, out):
+    """Without Isaac Sim: four matplotlib views of the asset's meshes and no physics."""
+    from pxr import Usd, UsdGeom
+
+    from .preview import sheet
+
+    stage = Usd.Stage.Open(str(asset))
+    cache = UsdGeom.XformCache()
+    meshes = []
+    for prim in stage.Traverse():
+        if not prim.IsA("Mesh") or UsdGeom.Imageable(prim).ComputePurpose() == UsdGeom.Tokens.guide:
+            continue
+        mesh = UsdGeom.Mesh(prim)
+        points = np.array(mesh.GetPointsAttr().Get(), dtype=float)
+        matrix = np.array(cache.GetLocalToWorldTransform(prim))
+        points = points @ matrix[:3, :3] + matrix[3, :3]
+        tris = np.array(mesh.GetFaceVertexIndicesAttr().Get(), dtype=int).reshape(-1, 3)
+        colour = mesh.GetDisplayColorAttr().Get()
+        meshes.append((points, tris, tuple(colour[0]) if colour else (0.7, 0.7, 0.7), 1.0))
+    sheet(meshes, out / "review.png")
+    report = {
+        "asset": str(asset),
+        "renderer": "software",
+        "contact_sheet": str(out / "review.png"),
+        "note": "No Isaac Sim found: shapes and colours only, physics and joints not checked.",
+    }
+    (out / "review.json").write_text(json.dumps(report, indent=1), encoding="utf-8")
+    return report

simready_forge/scan.py

@@ -0,0 +1,129 @@
+"""Generated textured meshes (GLB from an image-to-3D model such as TRELLIS.2) as scans at real size."""
+
+from pathlib import Path
+from typing import cast
+
+import numpy as np
+
+UNITS = {"m": 1.0, "cm": 0.01, "mm": 0.001}
+
+
+class Scan:
+    """A textured triangle mesh in model units: Z up, front at -Y. Faces are split into bodies with `faces_in`."""
+
+    def __init__(self, path, points, tris, uv, normals, images, scale):
+        self.path, self.points, self.tris, self.uv, self.normals = path, points, tris, uv, normals
+        self.images, self.scale = images, scale
+        self.used = np.zeros(len(tris), dtype=bool)
+        self.centres = points[tris].mean(axis=1)
+
+    def faces_in(self, lo, hi):
+        """Faces whose centre lies in the axis-aligned box lo..hi (model units) and are not assigned yet."""
+        lo, hi = np.asarray(lo, dtype=float), np.asarray(hi, dtype=float)
+        return np.all((self.centres >= lo) & (self.centres <= hi), axis=1) & ~self.used
+
+    def remaining(self):
+        """Faces not assigned to any body yet."""
+        return ~self.used
+
+    def face_colors(self):
+        """Each face's colour in the base texture at its mean UV, sRGB 0-255, one row per face (None without a
+        texture): to select a sole, a stripe or a label by colour. `uv` holds one pair per triangle corner, so
+        `uv[tris]` would read the wrong pixels."""
+        if self.images.get("base") is None or self.uv is None:
+            return None
+        image = np.asarray(self.images["base"].convert("RGB"), dtype=float)
+        uv = self.uv.reshape(-1, 3, 2).mean(1) % 1.0
+        px = (uv[:, 0] * (image.shape[1] - 1)).astype(int), ((1 - uv[:, 1]) * (image.shape[0] - 1)).astype(int)
+        return image[px[1], px[0]]
+
+    def views(self, path, size=1100):
+        """Front (looking +Y), side (looking -X) and top views with a grid in model units, to choose split boxes."""
+        import matplotlib
+
+        matplotlib.use("Agg")
+        import matplotlib.pyplot as plt
+        from matplotlib.collections import PolyCollection
+
+        lo, hi = self.points.min(0), self.points.max(0)
+        found = self.face_colors()
+        colour = np.full((len(self.tris), 3), 0.6) if found is None else found / 255
+        fig, axes = plt.subplots(1, 3, figsize=(size / 100, size / 300), dpi=100)
+        corners = self.points[self.tris]
+        for ax, (a, b, depth, sign, title) in zip(
+            axes,
+            (
+                (0, 2, 1, 1, "front: X right, Z up"),
+                (1, 2, 0, -1, "side: Y right, Z up"),
+                (0, 1, 2, -1, "top: X right, Y up"),
+            ),
+            strict=True,
+        ):
+            order = np.argsort(sign * corners[:, :, depth].mean(1))[::-1]
+            ax.add_collection(PolyCollection(corners[order][:, :, [a, b]], facecolors=colour[order], edgecolors="none"))
+            ax.set_xlim(lo[a], hi[a])
+            ax.set_ylim(lo[b], hi[b])
+            ax.set_aspect("equal")
+            ax.grid(visible=True, linewidth=0.4, alpha=0.6)
+            ax.set_title(title, fontsize=8)
+            ax.tick_params(labelsize=6)
+        fig.tight_layout()
+        fig.savefig(path)
+        plt.close(fig)
+        return path
+
+
+def load_scan(path, units="mm", height=None, longest=None, fit=None, turn=0, size=None):
+    """Load a GLB (Y-up glTF) as a Scan at real size. Give exactly one of:
+
+    height=  (Z extent) or longest= (largest extent): base on z=0, centred on X/Y;
+    size=(width, depth, height): scaled on each axis to the stated size (a request's 450 x 400 x 550), base on z=0,
+    centred on X/Y;
+    fit=(lo, hi): scaled uniformly to fit that box and placed in it, base on lo z (a part of an assembly).
+    turn: degrees about Z applied first, so the part faces the right way (the GLB's front ends up at -Y).
+    """
+    import trimesh
+
+    if sum(x is not None for x in (height, longest, fit, size)) != 1:
+        raise ValueError("give exactly one of height=, longest=, size=(w, d, h) or fit=(lo, hi) (model units)")
+    scene = cast(trimesh.Scene, trimesh.load(path, force="scene"))
+    mesh = cast(trimesh.Trimesh, scene.to_geometry())
+    mesh.apply_transform(trimesh.transformations.rotation_matrix(np.pi / 2, [1, 0, 0]))  # glTF Y-up -> Z-up
+    if turn:
+        mesh.apply_transform(trimesh.transformations.rotation_matrix(np.radians(turn), [0, 0, 1]))
+    s = UNITS[units]
+    if fit is not None:
+        lo_box, hi_box = np.asarray(fit[0], dtype=float) * s, np.asarray(fit[1], dtype=float) * s
+        mesh.apply_scale(float(np.min((hi_box - lo_box) / mesh.extents)))
+        lo, hi = mesh.bounds
+        centre = (lo_box + hi_box) / 2
+        mesh.apply_translation([centre[0] - (lo[0] + hi[0]) / 2, centre[1] - (lo[1] + hi[1]) / 2, lo_box[2] - lo[2]])
+    elif size is not None:
+        scale = np.eye(4)
+        scale[:3, :3] = np.diag(np.asarray(size, dtype=float) * s / mesh.extents)
+        mesh.apply_transform(scale)  # normals follow: trimesh recomputes them from the scaled faces
+        lo, hi = mesh.bounds
+        mesh.apply_translation([-(lo[0] + hi[0]) / 2, -(lo[1] + hi[1]) / 2, -lo[2]])
+    else:
+        one = height if height is not None else longest
+        target = float(one or 0) * s  # one of the two is set, checked above
+        extent = mesh.extents[2] if height is not None else mesh.extents.max()
+        mesh.apply_scale(target / float(extent))
+        lo, hi = mesh.bounds
+        mesh.apply_translation([-(lo[0] + hi[0]) / 2, -(lo[1] + hi[1]) / 2, -lo[2]])
+    material = getattr(mesh.visual, "material", None)
+    images = {
+        key: getattr(material, attr, None)
+        for key, attr in (
+            ("base", "baseColorTexture"),
+            ("metal_rough", "metallicRoughnessTexture"),
+            ("normal", "normalTexture"),
+        )
+    }
+    uv = getattr(mesh.visual, "uv", None)
+    tris = np.asarray(mesh.faces)
+    # trimesh already flips glTF's V to USD's lower-left origin: flipping again scrambles every texture
+    corner_uv = np.asarray(uv, dtype=float)[tris].reshape(-1, 2) if uv is not None else None
+    return Scan(
+        str(Path(path)), np.asarray(mesh.vertices) / s, tris, corner_uv, np.asarray(mesh.vertex_normals), images, s
+    )

simready_forge/trellis.py

@@ -0,0 +1,378 @@
+"""Local image-to-3D through a ComfyUI server: Z-Image-Turbo (text -> reference image) and TRELLIS.2 (image ->
+textured GLB). Effort sets the quality and how many candidates come back to choose from.
+
+    simready-forge trellis txt2img "<prompt>" <out_dir> [--effort low|medium|high] [--server URL]
+    simready-forge trellis image <image.png|jpg> <out_dir> [--effort low|medium|high] [--server URL]
+
+Effort   candidates   sampling        mesh faces   textures
+low      1            fast            80k          1024
+medium   2            template        150k         2048
+high     4            more steps      300k         2048 + finer remesh
+The server defaults to $COMFYUI_URL or http://127.0.0.1:8188. It needs ComfyUI's native TRELLIS.2 nodes and the
+models of its "3d_pixal3d_trellis2_image_to_model" and Z-Image-Turbo templates: trellis_2_int8_convrot,
+trellis_2_shape_vae_bf16, trellis_2_texture_vae_bf16, dino_v3_L_naf_fp32, birefnet, z_image_turbo_bf16,
+qwen_3_4b, ae. Prints one JSON line with the files written.
+"""
+
+import argparse
+import json
+import os
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+import uuid
+from pathlib import Path
+
+EFFORT = {
+    "low": {
+        "candidates": 1,
+        "steps": (8, 12, 8, 8),
+        "upsample": 1024,
+        "remesh": 512,
+        "faces": 80000,
+        "texture": 1024,
+        "normal": 1024,
+        "ao": 512,
+    },
+    "medium": {
+        "candidates": 2,
+        "steps": (12, 20, 12, 12),
+        "upsample": 1536,
+        "remesh": 768,
+        "faces": 150000,
+        "texture": 2048,
+        "normal": 2048,
+        "ao": 1024,
+    },
+    "high": {
+        "candidates": 4,
+        "steps": (16, 28, 16, 16),
+        "upsample": 1536,
+        "remesh": 896,
+        "faces": 300000,
+        "texture": 2048,
+        "normal": 2048,
+        "ao": 2048,
+    },
+}
+
+
+class Comfy:
+    def __init__(self, server):
+        # every request goes to this server, so the urlopen calls below can only reach http or https
+        if urllib.parse.urlsplit(server).scheme not in ("http", "https"):
+            raise ValueError(f"the ComfyUI server must be an http or https URL, not {server!r}")
+        self.server = server.rstrip("/")
+
+    @staticmethod
+    def _read(request, tries=4):
+        """The response body; a connection that fails to open is retried (a busy machine ran out of local ports, and
+        a 2-candidate run lost its second candidate)."""
+        for attempt in range(tries):
+            try:
+                with urllib.request.urlopen(request) as response:  # noqa: S310 (checked scheme in __init__)
+                    return response.read()
+            except (urllib.error.URLError, ConnectionError):
+                if attempt == tries - 1:
+                    raise
+                time.sleep(5 * (attempt + 1))
+        return b""
+
+    def post(self, path, payload):
+        request = urllib.request.Request(  # noqa: S310 (checked scheme)
+            self.server + path, data=json.dumps(payload).encode(), headers={"Content-Type": "application/json"}
+        )
+        return json.loads(self._read(request))
+
+    def upload(self, image):
+        image = Path(image)
+        boundary = uuid.uuid4().hex
+        body = (
+            (
+                f'--{boundary}\r\nContent-Disposition: form-data; name="image"; filename="{image.name}"\r\n'
+                f"Content-Type: application/octet-stream\r\n\r\n"
+            ).encode()
+            + image.read_bytes()
+            + f'\r\n--{boundary}\r\nContent-Disposition: form-data; name="overwrite"\r\n\r\n'.encode()
+            + f"true\r\n--{boundary}--\r\n".encode()
+        )
+        request = urllib.request.Request(  # noqa: S310 (checked scheme)
+            self.server + "/upload/image",
+            data=body,
+            headers={"Content-Type": f"multipart/form-data; boundary={boundary}"},
+        )
+        return json.loads(self._read(request))["name"]
+
+    def run(self, graph, timeout=3600):
+        prompt_id = self.post("/prompt", {"prompt": graph, "client_id": "simready_kit"})["prompt_id"]
+        start = time.time()
+        while time.time() - start < timeout:
+            history = json.loads(self._read(f"{self.server}/history/{prompt_id}"))
+            if prompt_id in history:
+                status = history[prompt_id].get("status", {})
+                if status.get("status_str") == "error":
+                    raise RuntimeError(json.dumps(status.get("messages", status))[:3000])
+                return history[prompt_id]["outputs"]
+            time.sleep(2)
+        raise TimeoutError(prompt_id)
+
+    def fetch(self, outputs, kind, target):
+        for value in outputs.values():
+            for item in value.get(kind, []) if isinstance(value, dict) else []:
+                query = urllib.parse.urlencode(
+                    {
+                        "filename": item["filename"],
+                        "subfolder": item.get("subfolder", ""),
+                        "type": item.get("type", "output"),
+                    }
+                )
+                Path(target).write_bytes(self._read(f"{self.server}/view?{query}"))
+                return target
+        raise RuntimeError(f"no {kind} output in {list(outputs)}")
+
+
+def image3d_graph(image_name, seed, p, prefix):
+    g = {}
+
+    def node(i, cls, **inputs):
+        g[str(i)] = {"class_type": cls, "inputs": inputs}
+
+    def ref(i, slot=0):
+        return [str(i), slot]
+
+    s1, s2, s3, s4 = p["steps"]
+    node(122, "LoadImage", image=image_name)
+    node(193, "LoadBackgroundRemovalModel", bg_removal_name="birefnet.safetensors")
+    node(192, "RemoveBackground", bg_removal_model=ref(193), image=ref(122))
+    node(
+        312,
+        "ImageCropToMask",
+        images=ref(122),
+        masks=ref(192),
+        width=1024,
+        height=1024,
+        pad_factor=1.1,
+        grow_mask=0,
+        background="#000000",
+    )
+    node(15, "CLIPVisionLoader", clip_name="dino_v3_L_naf_fp32.safetensors")
+    node(40, "UNETLoader", unet_name="trellis_2_int8_convrot.safetensors", weight_dtype="default")
+    node(299, "Trellis2Conditioning", clip_vision_model=ref(15), image=ref(312))
+    node(199, "CFGOverride", model=ref(40), cfg=1, start_percent=0.667, end_percent=1)
+    node(125, "RescaleCFG", model=ref(199), multiplier=0.7)
+    node(108, "ModelSamplingSD3", model=ref(125), shift=5)
+    node(87, "EmptyTrellis2LatentStructure", batch_size=1)
+    node(
+        3,
+        "KSampler",
+        model=ref(108),
+        seed=seed + 14,
+        steps=s1,
+        cfg=7.5,
+        sampler_name="euler",
+        scheduler="normal",
+        positive=ref(299, 0),
+        negative=ref(299, 1),
+        latent_image=ref(87),
+        denoise=1,
+    )
+    node(117, "VAELoader", vae_name="trellis_2_shape_vae_bf16.safetensors")
+    node(118, "VAELoader", vae_name="trellis_2_texture_vae_bf16.safetensors")
+    node(119, "VaeDecodeStructureTrellis2", samples=ref(3), vae=ref(117), resolution="32")
+    node(91, "Trellis2ShapeStage", positive=ref(299, 0), negative=ref(299, 1), voxel=ref(119))
+    node(279, "CFGOverride", model=ref(40), cfg=1, start_percent=0.769, end_percent=1)
+    node(126, "RescaleCFG", model=ref(279), multiplier=0.5)
+    node(
+        18,
+        "KSampler",
+        model=ref(126),
+        seed=seed,
+        steps=s2,
+        cfg=7.5,
+        sampler_name="euler",
+        scheduler="normal",
+        positive=ref(91, 0),
+        negative=ref(91, 1),
+        latent_image=ref(91, 2),
+        denoise=1,
+    )
+    node(
+        94,
+        "Trellis2UpsampleStage",
+        positive=ref(91, 0),
+        negative=ref(91, 1),
+        shape_latent=ref(18),
+        vae=ref(117),
+        target_resolution=p["upsample"],
+    )
+    node(
+        23,
+        "KSampler",
+        model=ref(126),
+        seed=seed,
+        steps=s3,
+        cfg=7.5,
+        sampler_name="euler",
+        scheduler="simple",
+        positive=ref(94, 0),
+        negative=ref(94, 1),
+        latent_image=ref(94, 2),
+        denoise=1,
+    )
+    node(92, "VaeDecodeShapeTrellis", samples=ref(23), vae=ref(117))
+    node(98, "Trellis2TextureStage", positive=ref(94, 0), negative=ref(94, 1), shape_latent=ref(23))
+    node(
+        12,
+        "KSampler",
+        model=ref(40),
+        seed=seed + 1,
+        steps=s4,
+        cfg=1,
+        sampler_name="euler",
+        scheduler="normal",
+        positive=ref(98, 0),
+        negative=ref(98, 1),
+        latent_image=ref(98, 2),
+        denoise=1,
+    )
+    node(93, "VaeDecodeTextureTrellis", samples=ref(12), vae=ref(118), shape_subdivides=ref(92, 1))
+    node(202, "GetMeshInfo", mesh=ref(92))
+    g["241"] = {
+        "class_type": "RemeshMesh",
+        "inputs": {
+            "mesh": ref(202),
+            "resolution": p["remesh"],
+            "sign_mode": "solid",
+            "sign_mode.fill": 20.0,
+            "sign_mode.qef": False,
+            "band": 1.0,
+            "project_back": 0.0,
+            "fix_poles": False,
+            "smooth_iters": 20,
+            "drop_small_components": 0.01,
+            "precluster_max_verts": 20000000,
+        },
+    }
+    node(186, "DecimateMesh", mesh=ref(241), target_face_count=p["faces"], placement_mode="midpoint")
+    node(238, "MeshSmoothNormals", mesh=ref(186), crease_angle=180)
+    node(196, "UnwrapMesh", mesh=ref(238), segmenter="pec", resolution=p["texture"], padding=1, weld_distance=0.0002)
+    node(
+        147,
+        "BakeTextureFromVoxel",
+        mesh=ref(196),
+        voxel_colors=ref(93),
+        reference_mesh=ref(92),
+        texture_size=p["texture"],
+    )
+    node(
+        224,
+        "BakeNormalMapFromMesh",
+        low_poly=ref(196),
+        high_poly=ref(241),
+        resolution=p["normal"],
+        cage_distance=0.05,
+        ignore_backfaces=True,
+    )
+    node(
+        233,
+        "BakeAmbientOcclusion",
+        low_poly=ref(196),
+        high_poly=ref(241),
+        resolution=p["ao"],
+        samples=64,
+        max_distance=0.71,
+        strength=1,
+        bias=0.01,
+    )
+    node(
+        210,
+        "ApplyTextureToMesh",
+        mesh=ref(196),
+        base_color=ref(147, 0),
+        metallic=ref(147, 1),
+        roughness=ref(147, 2),
+        occlusion=ref(233),
+        normal_map=ref(224),
+    )
+    node(260, "MeshSmoothNormals", mesh=ref(210), crease_angle=180)
+    node(900, "SaveGLB", mesh=ref(260), filename_prefix=prefix)
+    node(901, "SaveImage", images=ref(312), filename_prefix=prefix + "_input")
+    return g
+
+
+def txt2img_graph(text, seed, prefix):
+    return {
+        "1": {
+            "class_type": "UNETLoader",
+            "inputs": {"unet_name": "z_image_turbo_bf16.safetensors", "weight_dtype": "default"},
+        },
+        "2": {
+            "class_type": "CLIPLoader",
+            "inputs": {"clip_name": "qwen_3_4b.safetensors", "type": "lumina2", "device": "default"},
+        },
+        "3": {"class_type": "VAELoader", "inputs": {"vae_name": "ae.safetensors"}},
+        "4": {"class_type": "CLIPTextEncode", "inputs": {"clip": ["2", 0], "text": text}},
+        "5": {"class_type": "ConditioningZeroOut", "inputs": {"conditioning": ["4", 0]}},
+        "6": {"class_type": "EmptySD3LatentImage", "inputs": {"width": 1024, "height": 1024, "batch_size": 1}},
+        "7": {"class_type": "ModelSamplingAuraFlow", "inputs": {"model": ["1", 0], "shift": 3}},
+        "8": {
+            "class_type": "KSampler",
+            "inputs": {
+                "model": ["7", 0],
+                "seed": seed,
+                "steps": 8,
+                "cfg": 1,
+                "sampler_name": "res_multistep",
+                "scheduler": "simple",
+                "positive": ["4", 0],
+                "negative": ["5", 0],
+                "latent_image": ["6", 0],
+                "denoise": 1,
+            },
+        },
+        "9": {"class_type": "VAEDecode", "inputs": {"samples": ["8", 0], "vae": ["3", 0]}},
+        "10": {"class_type": "SaveImage", "inputs": {"images": ["9", 0], "filename_prefix": prefix}},
+    }
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(prog="simready-forge trellis")
+    parser.add_argument("mode", choices=["txt2img", "image"])
+    parser.add_argument("source", help="text prompt (txt2img) or image path (image)")
+    parser.add_argument("out_dir")
+    parser.add_argument("--effort", default="medium", choices=list(EFFORT))
+    parser.add_argument("--server", default=os.environ.get("COMFYUI_URL", "http://127.0.0.1:8188"))
+    parser.add_argument("--seed", type=int, default=42)
+    args = parser.parse_args(argv)
+    comfy, p = Comfy(args.server), EFFORT[args.effort]
+    out = Path(args.out_dir)
+    out.mkdir(parents=True, exist_ok=True)
+    from .review import isaac_turn
+
+    with isaac_turn():  # the same GPU as Isaac Sim: one heavy job on the machine at a time
+        written, start = [], time.time()
+        if args.mode == "txt2img":
+            for k in range(p["candidates"]):
+                outputs = comfy.run(
+                    txt2img_graph(args.source, args.seed + 101 * k, f"simready_kit/ref_{uuid.uuid4().hex[:8]}")
+                )
+                written.append(str(comfy.fetch(outputs, "images", out / f"reference_{k}.png")))
+        else:
+            name = comfy.upload(args.source)
+            for k in range(p["candidates"]):
+                prefix = f"simready_kit/mesh_{uuid.uuid4().hex[:8]}"
+                outputs = comfy.run(image3d_graph(name, args.seed + 1000 * k, p, prefix))
+                written.append(str(comfy.fetch(outputs, "3d", out / f"candidate_{k}.glb")))
+                if k == 0:
+                    comfy.fetch(outputs, "images", out / "input_crop.png")
+        print(
+            json.dumps(
+                {"mode": args.mode, "effort": args.effort, "files": written, "seconds": round(time.time() - start, 1)}
+            )
+        )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())