@forgent3d/cad-runtime 0.1.2 → 0.1.4

package/README.md

@@ -9,7 +9,7 @@ This package is intentionally runtime-light:
 - no React
 - no database clients
 
-`cad-agent` and `cf-sandbox` can both depend on this package without coupling their deploy targets together.
+`@forgent3d/cloud` and `cf-sandbox` can both depend on this package without coupling their deploy targets together.
 
 ## Python Runtime Assets
 

package/dist/index.cjs

@@ -31,8 +31,7 @@ module.exports = __toCommonJS(index_exports);
 var SANDBOX_AUTH_SCHEME = "Bearer";
 var SANDBOX_API_PATHS = {
   resolve: "/v1/sandboxes/resolve",
-  runTool: "/v1/tools/run",
-  export: "/v1/export"
+  runTool: "/v1/tools/run"
 };
 function normalizeSandboxSecret(secret) {
   const normalized = secret?.trim();

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts","../src/sandbox-protocol.ts"],"sourcesContent":["export {\n  SANDBOX_API_PATHS,\n  SANDBOX_AUTH_SCHEME,\n  normalizeSandboxSecret,\n  sandboxAuthorizationHeader,\n  type SandboxApiPath,\n} from \"./sandbox-protocol.js\";\n","export const SANDBOX_AUTH_SCHEME = \"Bearer\";\n\nexport const SANDBOX_API_PATHS = {\n  resolve: \"/v1/sandboxes/resolve\",\n  runTool: \"/v1/tools/run\",\n  export: \"/v1/export\",\n} as const;\n\nexport type SandboxApiPath = (typeof SANDBOX_API_PATHS)[keyof typeof SANDBOX_API_PATHS];\n\nexport function normalizeSandboxSecret(secret: string | undefined): string | undefined {\n  const normalized = secret?.trim();\n  return normalized || undefined;\n}\n\nexport function sandboxAuthorizationHeader(secret: string | undefined): string | undefined {\n  const normalized = normalizeSandboxSecret(secret);\n  return normalized ? `${SANDBOX_AUTH_SCHEME} ${normalized}` : undefined;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAO,IAAM,sBAAsB;AAE5B,IAAM,oBAAoB;AAAA,EAC/B,SAAS;AAAA,EACT,SAAS;AAAA,EACT,QAAQ;AACV;AAIO,SAAS,uBAAuB,QAAgD;AACrF,QAAM,aAAa,QAAQ,KAAK;AAChC,SAAO,cAAc;AACvB;AAEO,SAAS,2BAA2B,QAAgD;AACzF,QAAM,aAAa,uBAAuB,MAAM;AAChD,SAAO,aAAa,GAAG,mBAAmB,IAAI,UAAU,KAAK;AAC/D;","names":[]}
+{"version":3,"sources":["../src/index.ts","../src/sandbox-protocol.ts"],"sourcesContent":["export {\n  SANDBOX_API_PATHS,\n  SANDBOX_AUTH_SCHEME,\n  normalizeSandboxSecret,\n  sandboxAuthorizationHeader,\n  type SandboxApiPath,\n} from \"./sandbox-protocol.js\";\n","export const SANDBOX_AUTH_SCHEME = \"Bearer\";\n\nexport const SANDBOX_API_PATHS = {\n  resolve: \"/v1/sandboxes/resolve\",\n  runTool: \"/v1/tools/run\",\n} as const;\n\nexport type SandboxApiPath = (typeof SANDBOX_API_PATHS)[keyof typeof SANDBOX_API_PATHS];\n\nexport function normalizeSandboxSecret(secret: string | undefined): string | undefined {\n  const normalized = secret?.trim();\n  return normalized || undefined;\n}\n\nexport function sandboxAuthorizationHeader(secret: string | undefined): string | undefined {\n  const normalized = normalizeSandboxSecret(secret);\n  return normalized ? `${SANDBOX_AUTH_SCHEME} ${normalized}` : undefined;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAO,IAAM,sBAAsB;AAE5B,IAAM,oBAAoB;AAAA,EAC/B,SAAS;AAAA,EACT,SAAS;AACX;AAIO,SAAS,uBAAuB,QAAgD;AACrF,QAAM,aAAa,QAAQ,KAAK;AAChC,SAAO,cAAc;AACvB;AAEO,SAAS,2BAA2B,QAAgD;AACzF,QAAM,aAAa,uBAAuB,MAAM;AAChD,SAAO,aAAa,GAAG,mBAAmB,IAAI,UAAU,KAAK;AAC/D;","names":[]}

package/dist/index.d.cts

@@ -2,7 +2,6 @@ declare const SANDBOX_AUTH_SCHEME = "Bearer";
 declare const SANDBOX_API_PATHS: {
     readonly resolve: "/v1/sandboxes/resolve";
     readonly runTool: "/v1/tools/run";
-    readonly export: "/v1/export";
 };
 type SandboxApiPath = (typeof SANDBOX_API_PATHS)[keyof typeof SANDBOX_API_PATHS];
 declare function normalizeSandboxSecret(secret: string | undefined): string | undefined;

package/dist/index.d.ts

@@ -2,7 +2,6 @@ declare const SANDBOX_AUTH_SCHEME = "Bearer";
 declare const SANDBOX_API_PATHS: {
     readonly resolve: "/v1/sandboxes/resolve";
     readonly runTool: "/v1/tools/run";
-    readonly export: "/v1/export";
 };
 type SandboxApiPath = (typeof SANDBOX_API_PATHS)[keyof typeof SANDBOX_API_PATHS];
 declare function normalizeSandboxSecret(secret: string | undefined): string | undefined;

package/dist/index.js

@@ -2,8 +2,7 @@
 var SANDBOX_AUTH_SCHEME = "Bearer";
 var SANDBOX_API_PATHS = {
   resolve: "/v1/sandboxes/resolve",
-  runTool: "/v1/tools/run",
-  export: "/v1/export"
+  runTool: "/v1/tools/run"
 };
 function normalizeSandboxSecret(secret) {
   const normalized = secret?.trim();

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/sandbox-protocol.ts"],"sourcesContent":["export const SANDBOX_AUTH_SCHEME = \"Bearer\";\n\nexport const SANDBOX_API_PATHS = {\n  resolve: \"/v1/sandboxes/resolve\",\n  runTool: \"/v1/tools/run\",\n  export: \"/v1/export\",\n} as const;\n\nexport type SandboxApiPath = (typeof SANDBOX_API_PATHS)[keyof typeof SANDBOX_API_PATHS];\n\nexport function normalizeSandboxSecret(secret: string | undefined): string | undefined {\n  const normalized = secret?.trim();\n  return normalized || undefined;\n}\n\nexport function sandboxAuthorizationHeader(secret: string | undefined): string | undefined {\n  const normalized = normalizeSandboxSecret(secret);\n  return normalized ? `${SANDBOX_AUTH_SCHEME} ${normalized}` : undefined;\n}\n"],"mappings":";AAAO,IAAM,sBAAsB;AAE5B,IAAM,oBAAoB;AAAA,EAC/B,SAAS;AAAA,EACT,SAAS;AAAA,EACT,QAAQ;AACV;AAIO,SAAS,uBAAuB,QAAgD;AACrF,QAAM,aAAa,QAAQ,KAAK;AAChC,SAAO,cAAc;AACvB;AAEO,SAAS,2BAA2B,QAAgD;AACzF,QAAM,aAAa,uBAAuB,MAAM;AAChD,SAAO,aAAa,GAAG,mBAAmB,IAAI,UAAU,KAAK;AAC/D;","names":[]}
+{"version":3,"sources":["../src/sandbox-protocol.ts"],"sourcesContent":["export const SANDBOX_AUTH_SCHEME = \"Bearer\";\n\nexport const SANDBOX_API_PATHS = {\n  resolve: \"/v1/sandboxes/resolve\",\n  runTool: \"/v1/tools/run\",\n} as const;\n\nexport type SandboxApiPath = (typeof SANDBOX_API_PATHS)[keyof typeof SANDBOX_API_PATHS];\n\nexport function normalizeSandboxSecret(secret: string | undefined): string | undefined {\n  const normalized = secret?.trim();\n  return normalized || undefined;\n}\n\nexport function sandboxAuthorizationHeader(secret: string | undefined): string | undefined {\n  const normalized = normalizeSandboxSecret(secret);\n  return normalized ? `${SANDBOX_AUTH_SCHEME} ${normalized}` : undefined;\n}\n"],"mappings":";AAAO,IAAM,sBAAsB;AAE5B,IAAM,oBAAoB;AAAA,EAC/B,SAAS;AAAA,EACT,SAAS;AACX;AAIO,SAAS,uBAAuB,QAAgD;AACrF,QAAM,aAAa,QAAQ,KAAK;AAChC,SAAO,cAAc;AACvB;AAEO,SAAS,2BAA2B,QAAgD;AACzF,QAAM,aAAa,uBAAuB,MAAM;AAChD,SAAO,aAAa,GAAG,mBAAmB,IAAI,UAAU,KAAK;AAC/D;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgent3d/cad-runtime",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Shared CAD runtime protocol, types, and pure utilities for Forgent3D cloud services.",
   "license": "MIT",
   "author": "Forgent3D",

package/python/export_runner.py

@@ -3,9 +3,9 @@ export_runner.py - Auto-managed by AI CAD Companion Viewer (do not edit manually
 ----------------------------------------------------------------------------
 Responsibilities:
   * Accept --model <name> (and legacy --part <name>);
-  * Optionally support on-demand exports via --export-format/--output (step/stl/brep);
-  * Load models/<model>/parts/<part-name>/part.py and read a geometry object named result;
-  * Export build123d geometry to .cache/<name>.brep (and STEP/STL) via OCCT APIs;
+  * Optionally support on-demand exports via --export-format/--output (step/stl/obj/brep/glb/3mf);
+  * Load models/<model>/assembly.py, part.py, or parts/<part-name>/part.py and read result;
+  * Export build123d geometry to .cache/<name>.brep and requested exchange/mesh formats;
   * Let the frontend parse BREP via occt-import-js for geometry inspection.
 """
 import os
@@ -18,8 +18,11 @@ if sys.platform == "win32":
 
 import argparse
 import json
+import struct
+import tempfile
 import time
 import traceback
+import zipfile
 
 HERE = os.path.dirname(os.path.abspath(__file__))
 PROJECT_ROOT = HERE
@@ -27,6 +30,58 @@ MODELS_DIR = os.path.join(PROJECT_ROOT, "models")
 CACHE_DIR = os.path.join(PROJECT_ROOT, ".cache")
 MODEL_KINDS = ("part",)
 
+# Sentinel-prefixed line emitted on stdout when --emit-build-json is passed, so a
+# caller can read the build summary (bbox/anchors/hasResult) from this single run
+# instead of a separate aicad-script build pass. Keep in sync with cf-sandbox rebuild.ts.
+BUILD_JSON_SENTINEL = "@@AICAD_BUILD_JSON@@"
+
+
+def _emit_build_json(payload) -> None:
+    print(BUILD_JSON_SENTINEL + json.dumps(payload, ensure_ascii=False, separators=(",", ":")))
+
+
+def _bbox_summary(shape):
+    if shape is None or not hasattr(shape, "bounding_box"):
+        return None
+    try:
+        bb = shape.bounding_box()
+        return {
+            "min": [float(bb.min.X), float(bb.min.Y), float(bb.min.Z)],
+            "max": [float(bb.max.X), float(bb.max.Y), float(bb.max.Z)],
+            "size": [
+                float(bb.max.X - bb.min.X),
+                float(bb.max.Y - bb.min.Y),
+                float(bb.max.Z - bb.min.Z),
+            ],
+        }
+    except Exception:
+        return None
+
+
+def _build_summary_payload(model_name, part_name, source_path, ns, result):
+    metadata = ns.get("metadata") if isinstance(ns, dict) else None
+    anchors = None
+    metadata_keys = []
+    if isinstance(metadata, dict):
+        metadata_keys = sorted(str(k) for k in metadata.keys())
+        if isinstance(metadata.get("anchors"), dict):
+            try:
+                anchors = _json_safe(metadata.get("anchors"))
+            except Exception:
+                anchors = None
+    return {
+        "ok": result is not None,
+        "script": "build",
+        "model": model_name,
+        "part": part_name,
+        "source": os.path.relpath(source_path, PROJECT_ROOT).replace(os.sep, "/") if source_path else None,
+        "resultType": type(result).__name__ if result is not None else None,
+        "hasResult": result is not None,
+        "bbox": _bbox_summary(result),
+        "metadataKeys": metadata_keys,
+        "metadataAnchors": anchors,
+    }
+
 
 def _looks_like_build123d(obj) -> bool:
     return any(c.__module__.startswith("build123d") for c in type(obj).__mro__)
@@ -94,6 +149,159 @@ def _write_stl(shape, path_out):
         raise RuntimeError(f"Unable to export STL: {exc}")
 
 
+def _xml_escape_text(value):
+    return (
+        str(value if value is not None else "")
+        .replace("&", "&amp;")
+        .replace("<", "&lt;")
+        .replace(">", "&gt;")
+    )
+
+
+def _xml_escape_attr(value):
+    return _xml_escape_text(value).replace('"', "&quot;").replace("'", "&apos;")
+
+
+def _format_3mf_number(value):
+    num = float(value)
+    if abs(num) < 1e-9:
+        num = 0.0
+    if num.is_integer():
+        return str(int(num))
+    return f"{num:.6f}".rstrip("0").rstrip(".") or "0"
+
+
+def _rgba_to_3mf_color(rgba):
+    if not rgba:
+        rgba = (0xb0 / 255, 0xb0 / 255, 0xb0 / 255, 1.0)
+    values = []
+    for i, fallback in enumerate((0.69, 0.69, 0.69, 1.0)):
+        try:
+            v = float(rgba[i])
+        except Exception:
+            v = fallback
+        values.append(max(0, min(255, round(max(0.0, min(1.0, v)) * 255))))
+    return "#" + "".join(f"{v:02X}" for v in values)
+
+
+def _read_stl_triangles(path_in):
+    with open(path_in, "rb") as f:
+        data = f.read()
+    if len(data) >= 84:
+        tri_count = struct.unpack("<I", data[80:84])[0]
+        expected = 84 + tri_count * 50
+        if expected == len(data):
+            triangles = []
+            offset = 84
+            for _ in range(tri_count):
+                values = struct.unpack("<12fH", data[offset:offset + 50])
+                triangles.append((
+                    (values[3], values[4], values[5]),
+                    (values[6], values[7], values[8]),
+                    (values[9], values[10], values[11]),
+                ))
+                offset += 50
+            return triangles
+
+    text = data.decode("utf-8", errors="ignore")
+    vertices = []
+    for line in text.splitlines():
+        parts = line.strip().split()
+        if len(parts) >= 4 and parts[0].lower() == "vertex":
+            try:
+                vertices.append((float(parts[1]), float(parts[2]), float(parts[3])))
+            except ValueError:
+                pass
+    if len(vertices) < 3 or len(vertices) % 3 != 0:
+        raise RuntimeError("Unable to parse STL triangles for mesh export")
+    return [(vertices[i], vertices[i + 1], vertices[i + 2]) for i in range(0, len(vertices), 3)]
+
+
+def _write_obj_mesh(triangles, path_out, title="Forgent3D model"):
+    if not triangles:
+        raise RuntimeError("OBJ export found no triangles")
+    with open(path_out, "w", encoding="utf-8", newline="\n") as f:
+        f.write("# Forgent3D OBJ export\n")
+        f.write(f"o {_xml_escape_text(title or 'model')}\n")
+        for tri in triangles:
+            for vertex in tri:
+                f.write(
+                    f"v {_format_3mf_number(vertex[0])} "
+                    f"{_format_3mf_number(vertex[1])} "
+                    f"{_format_3mf_number(vertex[2])}\n"
+                )
+        for i in range(0, len(triangles) * 3, 3):
+            f.write(f"f {i + 1} {i + 2} {i + 3}\n")
+
+
+def _write_3mf_archive(triangles, path_out, title="Forgent3D model", color=None):
+    if not triangles:
+        raise RuntimeError("3MF export found no triangles")
+    display_color = _rgba_to_3mf_color(color)
+    vertices_xml = []
+    triangles_xml = []
+    vertex_index = 0
+    for tri in triangles:
+        indices = []
+        for vertex in tri:
+            indices.append(vertex_index)
+            vertices_xml.append(
+                f'          <vertex x="{_format_3mf_number(vertex[0])}" '
+                f'y="{_format_3mf_number(vertex[1])}" '
+                f'z="{_format_3mf_number(vertex[2])}" />'
+            )
+            vertex_index += 1
+        triangles_xml.append(
+            f'          <triangle v1="{indices[0]}" v2="{indices[1]}" v3="{indices[2]}" />'
+        )
+
+    safe_title = _xml_escape_text(str(title or "Forgent3D model")[:128])
+    model_xml = "\n".join([
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        '<model unit="millimeter" xml:lang="en-US" xmlns="http://schemas.microsoft.com/3dmanufacturing/core/2015/02">',
+        f'  <metadata name="Title">{safe_title}</metadata>',
+        '  <resources>',
+        '    <basematerials id="1">',
+        f'      <base name="Default" displaycolor="{display_color}" />',
+        '    </basematerials>',
+        f'    <object id="2" type="model" name="{_xml_escape_attr(title or "model")}" pid="1" pindex="0">',
+        '      <mesh>',
+        '        <vertices>',
+        *vertices_xml,
+        '        </vertices>',
+        '        <triangles>',
+        *triangles_xml,
+        '        </triangles>',
+        '      </mesh>',
+        '    </object>',
+        '  </resources>',
+        '  <build>',
+        '    <item objectid="2" />',
+        '  </build>',
+        '</model>',
+        '',
+    ])
+    content_types_xml = "\n".join([
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        '<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">',
+        '  <Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml" />',
+        '  <Override PartName="/3D/3dmodel.model" ContentType="application/vnd.ms-package.3dmanufacturing-3dmodel+xml" />',
+        '</Types>',
+        '',
+    ])
+    rels_xml = "\n".join([
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">',
+        '  <Relationship Target="/3D/3dmodel.model" Id="rel0" Type="http://schemas.microsoft.com/3dmanufacturing/2013/01/3dmodel" />',
+        '</Relationships>',
+        '',
+    ])
+    with zipfile.ZipFile(path_out, "w", compression=zipfile.ZIP_DEFLATED) as z:
+        z.writestr("[Content_Types].xml", content_types_xml)
+        z.writestr("_rels/.rels", rels_xml)
+        z.writestr("3D/3dmodel.model", model_xml)
+
+
 # Keep in sync with packages/electron/src/viewer-materials.ts MATERIAL_PRESETS.
 _VIEWER_PRESET_COLORS = {
     "cad_clay":         (0xc8 / 255, 0xd0 / 255, 0xdc / 255, 1.0),
@@ -218,6 +426,44 @@ def _write_glb(shape, path_out, params=None):
         raise RuntimeError(f"Unable to export GLB: {exc}")
 
 
+def _write_3mf(shape, path_out, params=None, title="Forgent3D model"):
+    fd, tmp_stl = tempfile.mkstemp(suffix=".stl")
+    os.close(fd)
+    try:
+        _write_stl(shape, tmp_stl)
+        triangles = _read_stl_triangles(tmp_stl)
+    finally:
+        try:
+            os.unlink(tmp_stl)
+        except OSError:
+            pass
+
+    color = None
+    if isinstance(params, dict):
+        viewer = params.get("__viewer") or params.get("viewer") or {}
+        materials = viewer.get("materials") if isinstance(viewer, dict) else None
+        if isinstance(materials, dict):
+            color = _resolve_material_color(materials.get("default"))
+    _write_3mf_archive(triangles, path_out, title=title, color=color)
+    return "export_runner.3mf_from_stl_mesh"
+
+
+def _write_obj(shape, path_out, title="Forgent3D model"):
+    fd, tmp_stl = tempfile.mkstemp(suffix=".stl")
+    os.close(fd)
+    try:
+        _write_stl(shape, tmp_stl)
+        triangles = _read_stl_triangles(tmp_stl)
+    finally:
+        try:
+            os.unlink(tmp_stl)
+        except OSError:
+            pass
+
+    _write_obj_mesh(triangles, path_out, title=title)
+    return "export_runner.obj_from_stl_mesh"
+
+
 def _resolve_model_source(model_name: str, part_name: str, source_override: str = None):
     if source_override:
         candidate = source_override
@@ -358,7 +604,7 @@ def _build_namespace(model_name: str, part_name: str, source_override: str = Non
     return ns, source_path, 0
 
 
-def build_one(model_name: str, part_name: str = None, export_format: str = "brep", output: str = None, source_override: str = None) -> int:
+def build_one(model_name: str, part_name: str = None, export_format: str = "brep", output: str = None, source_override: str = None, emit_build_json: bool = False) -> int:
     part_name = part_name or model_name
     build_started = time.perf_counter()
     ns, source_path, err = _build_namespace(model_name, part_name, source_override)
@@ -372,6 +618,8 @@ def build_one(model_name: str, part_name: str = None, export_format: str = "brep
         if candidate is not None:
             result = candidate
     if result is None:
+        if emit_build_json:
+            _emit_build_json(_build_summary_payload(model_name, part_name, source_path, ns, None))
         print(f"[export_runner] {source_path} must define a global result (or assembly) object (build123d).",
               file=sys.stderr)
         return 4
@@ -381,9 +629,11 @@ def build_one(model_name: str, part_name: str = None, export_format: str = "brep
     except Exception as exc:
         print(f"[export_runner] Failed to write metadata.json: {exc}", file=sys.stderr)
         return 8
+    if emit_build_json:
+        _emit_build_json(_build_summary_payload(model_name, part_name, source_path, ns, result))
 
     fmt = (export_format or "brep").strip().lower()
-    if fmt not in ("brep", "step", "stl", "glb"):
+    if fmt not in ("brep", "step", "stl", "obj", "glb", "3mf"):
         print(f"[export_runner] Unsupported export format: {fmt}", file=sys.stderr)
         return 7
 
@@ -402,6 +652,10 @@ def build_one(model_name: str, part_name: str = None, export_format: str = "brep
             method = _write_step(result, out)
         elif fmt == "glb":
             method = _write_glb(result, out, _load_model_params(model_name))
+        elif fmt == "obj":
+            method = _write_obj(result, out, model_name)
+        elif fmt == "3mf":
+            method = _write_3mf(result, out, _load_model_params(model_name), model_name)
         else:
             method = _write_stl(result, out)
         export_elapsed = time.perf_counter() - export_started
@@ -425,8 +679,10 @@ def main() -> int:
     parser.add_argument("--part", default=None, help="Legacy alias for --model")
     parser.add_argument("--part-name", default=None, help="Part directory name inside models/<model>/parts/")
     parser.add_argument("--source", default=None, help="Optional project-relative or absolute source file path (overrides default lookup)")
-    parser.add_argument("--export-format", default="brep", choices=["brep", "step", "stl", "glb"])
+    parser.add_argument("--export-format", default="brep", choices=["brep", "step", "stl", "obj", "glb", "3mf"])
     parser.add_argument("--output", default=None, help="Optional absolute path for exported file")
+    parser.add_argument("--emit-build-json", action="store_true",
+                        help="Emit a sentinel-prefixed build-summary JSON line on stdout (cloud rebuild fast path)")
     args = parser.parse_args()
     global PROJECT_ROOT, MODELS_DIR, CACHE_DIR
     PROJECT_ROOT = os.path.abspath(args.project) if args.project else HERE
@@ -435,7 +691,7 @@ def main() -> int:
     model_name = args.model or args.part
     if not model_name:
         parser.error("one of --model / --part is required")
-    return build_one(model_name, args.part_name or model_name, args.export_format, args.output, args.source)
+    return build_one(model_name, args.part_name or model_name, args.export_format, args.output, args.source, args.emit_build_json)
 
 
 if __name__ == "__main__":