Upload 8 files

README.md

@@ -102,3 +102,21 @@ This is still the right honest framing:
 - the scaffold becomes the mesh
 
 That middle layer is the product.
+
+
+## Flat repo layout
+
+This build is flattened so **every file lives in the repo root**.
+
+Upload these files directly into the Hugging Face Space root:
+
+- `app.py`
+- `generator.py`
+- `llm_parser.py`
+- `parser.py`
+- `requirements.txt`
+- `packages.txt`
+- `README.md`
+- `LICENSE`
+
+No `src/` folder is needed.

app.py

@@ -2,8 +2,8 @@ from __future__ import annotations
 
 import gradio as gr
 
-from src.generator import run_pipeline
-from src.llm_parser import DEFAULT_LOCAL_MODEL, MODEL_PRESETS
+from generator import run_pipeline
+from llm_parser import DEFAULT_LOCAL_MODEL, MODEL_PRESETS
 
 
 TITLE = "Particle Blueprint 3D"

generator.py

@@ -0,0 +1,299 @@
+from __future__ import annotations
+
+import math
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterable
+
+import numpy as np
+import trimesh
+from scipy import ndimage
+from skimage import measure
+
+from llm_parser import DEFAULT_LOCAL_MODEL, parse_prompt_with_local_llm
+from parser import PromptSpec, parse_prompt
+
+
+@dataclass
+class BuildArtifacts:
+    ply_path: str
+    glb_path: str
+    summary: dict
+
+
+SCALE_FACTORS = {
+    "small": 1.0,
+    "medium": 1.35,
+    "large": 1.85,
+}
+
+
+def _sample_box_surface(center, size, density: int, label: int) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    cx, cy, cz = center
+    sx, sy, sz = size
+    n = max(4, density)
+    u = np.linspace(-0.5, 0.5, n)
+    vv = np.linspace(-0.5, 0.5, n)
+    pts = []
+    normals = []
+    labels = []
+    for ax in (-1, 1):
+        x = np.full((n, n), cx + ax * sx / 2)
+        y, z = np.meshgrid(u * sy + cy, vv * sz + cz)
+        pts.append(np.column_stack([x.ravel(), y.ravel(), z.ravel()]))
+        normals.append(np.tile([ax, 0, 0], (n * n, 1)))
+        labels.append(np.full(n * n, label))
+    for ay in (-1, 1):
+        y = np.full((n, n), cy + ay * sy / 2)
+        x, z = np.meshgrid(u * sx + cx, vv * sz + cz)
+        pts.append(np.column_stack([x.ravel(), y.ravel(), z.ravel()]))
+        normals.append(np.tile([0, ay, 0], (n * n, 1)))
+        labels.append(np.full(n * n, label))
+    for az in (-1, 1):
+        z = np.full((n, n), cz + az * sz / 2)
+        x, y = np.meshgrid(u * sx + cx, vv * sy + cy)
+        pts.append(np.column_stack([x.ravel(), y.ravel(), z.ravel()]))
+        normals.append(np.tile([0, 0, az], (n * n, 1)))
+        labels.append(np.full(n * n, label))
+    return np.vstack(pts), np.vstack(normals), np.concatenate(labels)
+
+
+def _sample_ellipsoid_surface(center, radii, density: int, label: int) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    cx, cy, cz = center
+    rx, ry, rz = radii
+    nu = max(16, density * 3)
+    nv = max(10, density * 2)
+    u = np.linspace(0, 2 * math.pi, nu, endpoint=False)
+    v = np.linspace(-math.pi / 2, math.pi / 2, nv)
+    uu, vv = np.meshgrid(u, v)
+    x = cx + rx * np.cos(vv) * np.cos(uu)
+    y = cy + ry * np.cos(vv) * np.sin(uu)
+    z = cz + rz * np.sin(vv)
+    pts = np.column_stack([x.ravel(), y.ravel(), z.ravel()])
+    normals = np.column_stack([
+        (x - cx).ravel() / max(rx, 1e-6),
+        (y - cy).ravel() / max(ry, 1e-6),
+        (z - cz).ravel() / max(rz, 1e-6),
+    ])
+    normals /= np.linalg.norm(normals, axis=1, keepdims=True) + 1e-8
+    labels = np.full(len(pts), label)
+    return pts, normals, labels
+
+
+def _sample_cylinder_surface(center, radius, length, axis: str, density: int, label: int) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    cx, cy, cz = center
+    nt = max(18, density * 4)
+    nl = max(6, density)
+    theta = np.linspace(0, 2 * math.pi, nt, endpoint=False)
+    line = np.linspace(-length / 2, length / 2, nl)
+    tt, ll = np.meshgrid(theta, line)
+    if axis == "x":
+        x = cx + ll
+        y = cy + radius * np.cos(tt)
+        z = cz + radius * np.sin(tt)
+        normals = np.column_stack([np.zeros(x.size), np.cos(tt).ravel(), np.sin(tt).ravel()])
+    elif axis == "y":
+        x = cx + radius * np.cos(tt)
+        y = cy + ll
+        z = cz + radius * np.sin(tt)
+        normals = np.column_stack([np.cos(tt).ravel(), np.zeros(x.size), np.sin(tt).ravel()])
+    else:
+        x = cx + radius * np.cos(tt)
+        y = cy + radius * np.sin(tt)
+        z = cz + ll
+        normals = np.column_stack([np.cos(tt).ravel(), np.sin(tt).ravel(), np.zeros(x.size)])
+    pts = np.column_stack([x.ravel(), y.ravel(), z.ravel()])
+    labels = np.full(len(pts), label)
+    return pts, normals, labels
+
+
+def build_particle_blueprint(
+    prompt: str,
+    detail: int = 24,
+    parser_mode: str = "heuristic",
+    model_id: str | None = None,
+) -> tuple[np.ndarray, np.ndarray, np.ndarray, PromptSpec, str]:
+    parser_mode = (parser_mode or "heuristic").strip().lower()
+    parser_backend = "heuristic"
+    if parser_mode.startswith("local"):
+        spec = parse_prompt_with_local_llm(prompt, model_id=model_id or DEFAULT_LOCAL_MODEL)
+        parser_backend = f"local_llm:{model_id or DEFAULT_LOCAL_MODEL}"
+    else:
+        spec = parse_prompt(prompt)
+    scale = SCALE_FACTORS[spec.scale]
+    density = max(6, detail)
+
+    parts = []
+    normals = []
+    labels = []
+
+    hull_len = 2.8 * scale
+    hull_w = 1.2 * scale
+    hull_h = 0.8 * scale
+
+    if spec.hull_style == "rounded":
+        p, n, l = _sample_ellipsoid_surface((0.0, 0.0, 0.0), (hull_len / 2, hull_w / 2, hull_h / 2), density, 0)
+    elif spec.hull_style == "sleek":
+        p1, n1, l1 = _sample_ellipsoid_surface((0.12 * scale, 0.0, 0.0), (hull_len / 2.3, hull_w / 2.8, hull_h / 2.6), density, 0)
+        p2, n2, l2 = _sample_box_surface((-0.15 * scale, 0.0, -0.02 * scale), (hull_len * 0.52, hull_w * 0.5, hull_h * 0.55), density // 2, 0)
+        p = np.vstack([p1, p2])
+        n = np.vstack([n1, n2])
+        l = np.concatenate([l1, l2])
+    else:
+        p, n, l = _sample_box_surface((0.0, 0.0, 0.0), (hull_len, hull_w, hull_h), density, 0)
+    parts.append(p)
+    normals.append(n)
+    labels.append(l)
+
+    cockpit_center = (hull_len / 2 - hull_len * spec.cockpit_ratio * 0.8, 0.0, hull_h * 0.14)
+    cp, cn, cl = _sample_ellipsoid_surface(cockpit_center, (hull_len * spec.cockpit_ratio, hull_w * 0.22, hull_h * 0.24), density // 2, 1)
+    parts.append(cp)
+    normals.append(cn)
+    labels.append(cl)
+
+    if spec.cargo_ratio > 0.16:
+        cargo_center = (-hull_len * 0.18, 0.0, -hull_h * 0.06)
+        cargo_size = (hull_len * spec.cargo_ratio, hull_w * 0.76, hull_h * 0.6)
+        pp, pn, pl = _sample_box_surface(cargo_center, cargo_size, density // 2, 2)
+        parts.append(pp)
+        normals.append(pn)
+        labels.append(pl)
+
+    if spec.wing_span > 0:
+        wing_length = hull_len * 0.34
+        wing_width = hull_w * 0.18
+        wing_height = hull_h * 0.08
+        yoff = hull_w * 0.45 + wing_width * 0.6
+        for side in (-1, 1):
+            wc = (-0.1 * scale, side * yoff, -0.04 * scale)
+            pp, pn, pl = _sample_box_surface(wc, (wing_length, wing_width, wing_height), max(6, density // 3), 3)
+            parts.append(pp)
+            normals.append(pn)
+            labels.append(pl)
+
+    engine_radius = 0.14 * scale if spec.object_type != "fighter" else 0.1 * scale
+    engine_length = 0.48 * scale
+    engine_y_positions = np.linspace(-hull_w * 0.32, hull_w * 0.32, spec.engine_count)
+    for ypos in engine_y_positions:
+        ec = (-hull_len / 2 + engine_length * 0.3, ypos, 0.0)
+        pp, pn, pl = _sample_cylinder_surface(ec, engine_radius, engine_length, "x", max(6, density // 3), 4)
+        parts.append(pp)
+        normals.append(pn)
+        labels.append(pl)
+
+    if spec.fin_height > 0:
+        fin_center = (-hull_len * 0.25, 0.0, hull_h * 0.42)
+        fin_size = (hull_len * 0.18, hull_w * 0.1, hull_h * max(spec.fin_height, 0.12))
+        pp, pn, pl = _sample_box_surface(fin_center, fin_size, max(6, density // 3), 5)
+        parts.append(pp)
+        normals.append(pn)
+        labels.append(pl)
+
+    if spec.landing_gear:
+        gear_x = np.array([-hull_len * 0.18, hull_len * 0.12])
+        gear_y = np.array([-hull_w * 0.28, hull_w * 0.28])
+        for gx in gear_x:
+            for gy in gear_y:
+                gc = (gx, gy, -hull_h * 0.45)
+                pp, pn, pl = _sample_cylinder_surface(gc, 0.04 * scale, 0.22 * scale, "z", max(5, density // 5), 6)
+                parts.append(pp)
+                normals.append(pn)
+                labels.append(pl)
+
+    points = np.vstack(parts)
+    point_normals = np.vstack(normals)
+    point_labels = np.concatenate(labels)
+
+    if spec.asymmetry > 0:
+        mask = points[:, 1] > 0
+        points[mask, 2] += spec.asymmetry * np.sin(points[mask, 0] * 2.0)
+
+    return points.astype(np.float32), point_normals.astype(np.float32), point_labels.astype(np.int32), spec, parser_backend
+
+
+def points_to_mesh(points: np.ndarray, pitch: float = 0.08, padding: int = 5, sigma: float = 1.2, level: float = 0.11) -> trimesh.Trimesh:
+    mins = points.min(axis=0) - padding * pitch
+    maxs = points.max(axis=0) + padding * pitch
+    dims = np.ceil((maxs - mins) / pitch).astype(int) + 1
+    dims = np.clip(dims, 24, 192)
+
+    grid = np.zeros(tuple(dims.tolist()), dtype=np.float32)
+    coords = ((points - mins) / pitch).astype(int)
+    coords = np.clip(coords, 0, dims - 1)
+    np.add.at(grid, (coords[:, 0], coords[:, 1], coords[:, 2]), 1.0)
+
+    grid = ndimage.gaussian_filter(grid, sigma=sigma)
+    verts, faces, normals, _ = measure.marching_cubes(grid, level=level)
+    verts = verts * pitch + mins
+
+    mesh = trimesh.Trimesh(vertices=verts, faces=faces, vertex_normals=normals, process=True)
+    mesh.update_faces(mesh.nondegenerate_faces())
+    mesh.update_faces(mesh.unique_faces())
+    mesh.remove_unreferenced_vertices()
+    try:
+        mesh.fill_holes()
+    except Exception:
+        pass
+    try:
+        trimesh.smoothing.filter_humphrey(mesh, iterations=2)
+    except Exception:
+        pass
+    return mesh
+
+
+def export_point_cloud_as_ply(points: np.ndarray, labels: np.ndarray, path: str) -> str:
+    colors = np.array([
+        [170, 170, 180],
+        [120, 180, 255],
+        [255, 190, 120],
+        [180, 180, 255],
+        [255, 120, 120],
+        [200, 255, 180],
+        [255, 255, 180],
+    ], dtype=np.uint8)
+    c = colors[labels % len(colors)]
+    pc = trimesh.points.PointCloud(vertices=points, colors=c)
+    pc.export(path)
+    return path
+
+
+def export_mesh_as_glb(mesh: trimesh.Trimesh, path: str) -> str:
+    mesh.visual.vertex_colors = np.tile(np.array([[185, 190, 200, 255]], dtype=np.uint8), (len(mesh.vertices), 1))
+    mesh.export(path)
+    return path
+
+
+def run_pipeline(
+    prompt: str,
+    detail: int = 24,
+    voxel_pitch: float = 0.08,
+    parser_mode: str = "heuristic",
+    model_id: str | None = None,
+) -> BuildArtifacts:
+    points, normals, labels, spec, parser_backend = build_particle_blueprint(
+        prompt,
+        detail=detail,
+        parser_mode=parser_mode,
+        model_id=model_id,
+    )
+    mesh = points_to_mesh(points, pitch=voxel_pitch)
+
+    out_dir = Path(tempfile.mkdtemp(prefix="particle_blueprint_"))
+    ply_path = str(out_dir / "blueprint.ply")
+    glb_path = str(out_dir / "mesh.glb")
+    export_point_cloud_as_ply(points, labels, ply_path)
+    export_mesh_as_glb(mesh, glb_path)
+
+    summary = {
+        "prompt": prompt,
+        "parser_backend": parser_backend,
+        "spec": spec.to_dict(),
+        "point_count": int(len(points)),
+        "vertex_count": int(len(mesh.vertices)),
+        "face_count": int(len(mesh.faces)),
+        "bounds": mesh.bounds.round(3).tolist(),
+        "voxel_pitch": voxel_pitch,
+    }
+
+    return BuildArtifacts(ply_path=ply_path, glb_path=glb_path, summary=summary)

llm_parser.py

@@ -0,0 +1,167 @@
+from __future__ import annotations
+
+import json
+import os
+import re
+from functools import lru_cache
+from typing import Any
+
+from parser import PromptSpec, merge_prompt_specs, parse_prompt
+
+try:
+    import spaces  # type: ignore
+except Exception:  # pragma: no cover
+    class _SpacesShim:
+        @staticmethod
+        def GPU(*args, **kwargs):
+            def decorator(fn):
+                return fn
+            return decorator
+
+    spaces = _SpacesShim()  # type: ignore
+
+
+DEFAULT_LOCAL_MODEL = os.getenv("PB3D_LOCAL_MODEL", "Qwen/Qwen2.5-1.5B-Instruct")
+MODEL_PRESETS = {
+    "Qwen 2.5 1.5B": "Qwen/Qwen2.5-1.5B-Instruct",
+    "SmolLM2 1.7B": "HuggingFaceTB/SmolLM2-1.7B-Instruct",
+}
+
+JSON_SCHEMA_HINT = {
+    "object_type": ["cargo_hauler", "fighter", "shuttle", "freighter", "dropship", "drone"],
+    "scale": ["small", "medium", "large"],
+    "hull_style": ["boxy", "rounded", "sleek"],
+    "engine_count": "integer 1-6",
+    "wing_span": "float 0.0-0.6",
+    "cargo_ratio": "float 0.0-0.65",
+    "cockpit_ratio": "float 0.10-0.30",
+    "fin_height": "float 0.0-0.3",
+    "landing_gear": "boolean",
+    "asymmetry": "float 0.0-0.2",
+    "notes": "short string",
+}
+
+
+def _clamp(value: float, low: float, high: float) -> float:
+    return max(low, min(high, value))
+
+
+@lru_cache(maxsize=2)
+def _load_generation_components(model_id: str):
+    from transformers import AutoModelForCausalLM, AutoTokenizer
+    import torch
+
+    tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+
+    has_cuda = torch.cuda.is_available()
+    torch_dtype = torch.bfloat16 if has_cuda else torch.float32
+    model = AutoModelForCausalLM.from_pretrained(
+        model_id,
+        torch_dtype=torch_dtype,
+        device_map="auto",
+        low_cpu_mem_usage=True,
+        trust_remote_code=True,
+    )
+    return tokenizer, model
+
+
+@spaces.GPU(duration=45)
+def _generate_structured_json(prompt: str, model_id: str) -> dict[str, Any]:
+    import torch
+
+    tokenizer, model = _load_generation_components(model_id)
+
+    system = (
+        "You are a compact design parser for a procedural 3D generator. "
+        "Convert the user request into a single JSON object and output JSON only."
+    )
+    user = (
+        "Return a JSON object using this schema: "
+        f"{json.dumps(JSON_SCHEMA_HINT)}\n"
+        "Rules: choose the closest allowed enum values, stay conservative, infer hard-surface sci-fi vehicle structure, "
+        "never explain anything, never use markdown fences, and keep notes brief.\n"
+        f"Prompt: {prompt}"
+    )
+
+    messages = [
+        {"role": "system", "content": system},
+        {"role": "user", "content": user},
+    ]
+
+    if hasattr(tokenizer, "apply_chat_template"):
+        rendered = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+    else:
+        rendered = f"System: {system}\nUser: {user}\nAssistant:"
+
+    inputs = tokenizer(rendered, return_tensors="pt")
+    model_device = getattr(model, "device", None)
+    if model_device is not None:
+        inputs = {k: v.to(model_device) for k, v in inputs.items()}
+
+    with torch.no_grad():
+        output = model.generate(
+            **inputs,
+            max_new_tokens=220,
+            do_sample=False,
+            temperature=None,
+            top_p=None,
+            repetition_penalty=1.02,
+            pad_token_id=tokenizer.pad_token_id,
+            eos_token_id=tokenizer.eos_token_id,
+        )
+
+    new_tokens = output[0][inputs["input_ids"].shape[1]:]
+    text = tokenizer.decode(new_tokens, skip_special_tokens=True).strip()
+
+    match = re.search(r"\{.*\}", text, flags=re.S)
+    if not match:
+        raise ValueError("Local model did not return JSON.")
+    return json.loads(match.group(0))
+
+
+def _normalize_llm_payload(payload: dict[str, Any], original_prompt: str) -> PromptSpec:
+    def get_str(name: str, default: str) -> str:
+        value = str(payload.get(name, default)).strip().lower()
+        return value or default
+
+    def get_int(name: str, default: int, low: int, high: int) -> int:
+        try:
+            return int(_clamp(int(payload.get(name, default)), low, high))
+        except Exception:
+            return default
+
+    def get_float(name: str, default: float, low: float, high: float) -> float:
+        try:
+            return float(_clamp(float(payload.get(name, default)), low, high))
+        except Exception:
+            return default
+
+    landing_raw = payload.get("landing_gear", True)
+    if isinstance(landing_raw, bool):
+        landing_gear = landing_raw
+    else:
+        landing_gear = str(landing_raw).strip().lower() in {"1", "true", "yes", "y"}
+
+    return PromptSpec(
+        object_type=get_str("object_type", "cargo_hauler"),
+        scale=get_str("scale", "small"),
+        hull_style=get_str("hull_style", "boxy"),
+        engine_count=get_int("engine_count", 2, 1, 6),
+        wing_span=get_float("wing_span", 0.2, 0.0, 0.6),
+        cargo_ratio=get_float("cargo_ratio", 0.38, 0.0, 0.65),
+        cockpit_ratio=get_float("cockpit_ratio", 0.18, 0.10, 0.30),
+        fin_height=get_float("fin_height", 0.0, 0.0, 0.3),
+        landing_gear=landing_gear,
+        asymmetry=get_float("asymmetry", 0.0, 0.0, 0.2),
+        notes=str(payload.get("notes", original_prompt)).strip() or original_prompt,
+    )
+
+
+def parse_prompt_with_local_llm(prompt: str, model_id: str | None = None) -> PromptSpec:
+    model_id = model_id or DEFAULT_LOCAL_MODEL
+    heuristic = parse_prompt(prompt)
+    payload = _generate_structured_json(prompt=prompt, model_id=model_id)
+    llm_spec = _normalize_llm_payload(payload, original_prompt=prompt)
+    return merge_prompt_specs(heuristic, llm_spec)

parser.py

@@ -0,0 +1,148 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, asdict
+
+
+@dataclass
+class PromptSpec:
+    object_type: str = "cargo_hauler"
+    scale: str = "small"
+    hull_style: str = "boxy"
+    engine_count: int = 2
+    wing_span: float = 0.2
+    cargo_ratio: float = 0.38
+    cockpit_ratio: float = 0.18
+    fin_height: float = 0.0
+    landing_gear: bool = True
+    asymmetry: float = 0.0
+    notes: str = ""
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+TYPE_KEYWORDS = {
+    "fighter": "fighter",
+    "combat": "fighter",
+    "interceptor": "fighter",
+    "shuttle": "shuttle",
+    "freighter": "freighter",
+    "hauler": "cargo_hauler",
+    "cargo": "cargo_hauler",
+    "transport": "cargo_hauler",
+    "dropship": "dropship",
+    "drone": "drone",
+}
+
+STYLE_KEYWORDS = {
+    "boxy": "boxy",
+    "industrial": "boxy",
+    "hard-surface": "boxy",
+    "rounded": "rounded",
+    "sleek": "sleek",
+    "streamlined": "sleek",
+    "brutalist": "boxy",
+}
+
+SCALE_KEYWORDS = {
+    "tiny": "small",
+    "small": "small",
+    "compact": "small",
+    "medium": "medium",
+    "mid-size": "medium",
+    "large": "large",
+    "heavy": "large",
+    "huge": "large",
+}
+
+VALID_OBJECT_TYPES = {"cargo_hauler", "fighter", "shuttle", "freighter", "dropship", "drone"}
+VALID_SCALES = {"small", "medium", "large"}
+VALID_HULL_STYLES = {"boxy", "rounded", "sleek"}
+
+
+def _clamp(value: float, low: float, high: float) -> float:
+    return max(low, min(high, value))
+
+
+def merge_prompt_specs(primary: PromptSpec, secondary: PromptSpec) -> PromptSpec:
+    merged = PromptSpec(**primary.to_dict())
+
+    if secondary.object_type in VALID_OBJECT_TYPES:
+        merged.object_type = secondary.object_type
+    if secondary.scale in VALID_SCALES:
+        merged.scale = secondary.scale
+    if secondary.hull_style in VALID_HULL_STYLES:
+        merged.hull_style = secondary.hull_style
+
+    merged.engine_count = int(_clamp(secondary.engine_count, 1, 6))
+    merged.wing_span = float(_clamp(secondary.wing_span, 0.0, 0.6))
+    merged.cargo_ratio = float(_clamp(secondary.cargo_ratio, 0.0, 0.65))
+    merged.cockpit_ratio = float(_clamp(secondary.cockpit_ratio, 0.10, 0.30))
+    merged.fin_height = float(_clamp(secondary.fin_height, 0.0, 0.3))
+    merged.landing_gear = bool(secondary.landing_gear)
+    merged.asymmetry = float(_clamp(secondary.asymmetry, 0.0, 0.2))
+    merged.notes = secondary.notes or primary.notes
+
+    if merged.object_type in {"fighter", "drone"}:
+        merged.cargo_ratio = min(merged.cargo_ratio, 0.20)
+        if merged.hull_style == "boxy":
+            merged.hull_style = "sleek"
+
+    return merged
+
+
+def parse_prompt(prompt: str) -> PromptSpec:
+    text = prompt.lower().strip()
+    spec = PromptSpec(notes=prompt.strip())
+
+    for key, value in TYPE_KEYWORDS.items():
+        if key in text:
+            spec.object_type = value
+            break
+
+    for key, value in STYLE_KEYWORDS.items():
+        if key in text:
+            spec.hull_style = value
+            break
+
+    for key, value in SCALE_KEYWORDS.items():
+        if key in text:
+            spec.scale = value
+            break
+
+    if any(word in text for word in ["wing", "wings"]):
+        spec.wing_span = 0.42 if spec.object_type == "fighter" else 0.28
+    if any(word in text for word in ["no wings", "wingless"]):
+        spec.wing_span = 0.0
+
+    if any(word in text for word in ["cargo bay", "cargo hold", "container", "freight"]):
+        spec.cargo_ratio = 0.48
+
+    if any(word in text for word in ["big cockpit", "large cockpit", "glass nose"]):
+        spec.cockpit_ratio = 0.24
+    if any(word in text for word in ["small cockpit", "tiny cockpit"]):
+        spec.cockpit_ratio = 0.13
+
+    if any(word in text for word in ["fin", "tail", "vertical stabilizer"]):
+        spec.fin_height = 0.18 if spec.object_type != "fighter" else 0.12
+
+    if any(word in text for word in ["hover", "hovercraft", "antigrav"]):
+        spec.landing_gear = False
+
+    if spec.object_type in {"fighter", "drone"}:
+        spec.engine_count = 1 if "single engine" in text else 2
+        spec.cargo_ratio = min(spec.cargo_ratio, 0.18)
+        spec.hull_style = "sleek"
+    elif spec.object_type in {"cargo_hauler", "freighter", "dropship"}:
+        spec.engine_count = 4 if any(x in text for x in ["4 engine", "four engine", "quad engine"]) else 2
+        spec.hull_style = "boxy" if spec.hull_style == "sleek" else spec.hull_style
+
+    numeric_engine = re.search(r"(\d+)\s*(?:engine|engines)", text)
+    if numeric_engine:
+        spec.engine_count = max(1, min(6, int(numeric_engine.group(1))))
+
+    if any(word in text for word in ["asymmetric", "uneven", "offset"]):
+        spec.asymmetry = 0.12
+
+    return spec