elalish
diff --git a/‎bindings/c/include/manifold/manifoldc.h‎
Lines changed: 4 additions & 2 deletions b/‎bindings/c/include/manifold/manifoldc.h‎
Lines changed: 4 additions & 2 deletions
diff --git a/‎bindings/c/manifoldc.cpp‎
Lines changed: 12 additions & 4 deletions b/‎bindings/c/manifoldc.cpp‎
Lines changed: 12 additions & 4 deletions
diff --git a/‎bindings/python/manifold3d.cpp‎
Lines changed: 6 additions & 2 deletions b/‎bindings/python/manifold3d.cpp‎
Lines changed: 6 additions & 2 deletions
diff --git a/‎bindings/wasm/bindings.cpp‎
Lines changed: 1 addition & 1 deletion b/‎bindings/wasm/bindings.cpp‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎bindings/wasm/bindings.js‎
Lines changed: 15 additions & 1 deletion b/‎bindings/wasm/bindings.js‎
Lines changed: 15 additions & 1 deletion
diff --git a/‎bindings/wasm/manifold-encapsulated-types.d.ts‎
Lines changed: 47 additions & 7 deletions b/‎bindings/wasm/manifold-encapsulated-types.d.ts‎
Lines changed: 47 additions & 7 deletions
diff --git a/‎include/manifold/manifold.h‎
Lines changed: 2 additions & 2 deletions b/‎include/manifold/manifold.h‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎include/manifold/mesh.h‎
Lines changed: 24 additions & 14 deletions b/‎include/manifold/mesh.h‎
Lines changed: 24 additions & 14 deletions
diff --git a/‎src/boolean_result.cpp‎
Lines changed: 15 additions & 3 deletions b/‎src/boolean_result.cpp‎
Lines changed: 15 additions & 3 deletions
diff --git a/‎src/csg_tree.cpp‎
Lines changed: 12 additions & 0 deletions b/‎src/csg_tree.cpp‎
Lines changed: 12 additions & 0 deletions
@@ -448,7 +448,8 @@ float manifold_meshgl_tolerance(ManifoldMeshGL* m);
 size_t manifold_meshgl_run_flags_length(ManifoldMeshGL* m);
 uint8_t* manifold_meshgl_run_flags(void* mem, ManifoldMeshGL* m);
 size_t manifold_meshgl_num_run(ManifoldMeshGL* m);
-void manifold_meshgl_update_normals(ManifoldMeshGL* m, int normal_idx);
+int manifold_meshgl_backside(ManifoldMeshGL* m, size_t run);
+int manifold_meshgl_has_normals(ManifoldMeshGL* m, size_t run);
 
 size_t manifold_meshgl64_num_prop(ManifoldMeshGL64* m);
 size_t manifold_meshgl64_num_vert(ManifoldMeshGL64* m);
@@ -474,7 +475,8 @@ double manifold_meshgl64_tolerance(ManifoldMeshGL64* m);
 size_t manifold_meshgl64_run_flags_length(ManifoldMeshGL64* m);
 uint8_t* manifold_meshgl64_run_flags(void* mem, ManifoldMeshGL64* m);
 size_t manifold_meshgl64_num_run(ManifoldMeshGL64* m);
-void manifold_meshgl64_update_normals(ManifoldMeshGL64* m, int normal_idx);
+int manifold_meshgl64_backside(ManifoldMeshGL64* m, size_t run);
+int manifold_meshgl64_has_normals(ManifoldMeshGL64* m, size_t run);
 
 // Triangulation
 
 
@@ -694,8 +694,12 @@ size_t manifold_meshgl_num_run(ManifoldMeshGL* m) {
   return from_c(m)->NumRun();
 }
 
-void manifold_meshgl_update_normals(ManifoldMeshGL* m, int normal_idx) {
-  from_c(m)->UpdateNormals(normal_idx);
+int manifold_meshgl_backside(ManifoldMeshGL* m, size_t run) {
+  return from_c(m)->Backside(run) ? 1 : 0;
+}
+
+int manifold_meshgl_has_normals(ManifoldMeshGL* m, size_t run) {
+  return from_c(m)->HasNormals(run) ? 1 : 0;
 }
 
 size_t manifold_meshgl64_num_prop(ManifoldMeshGL64* m) {
@@ -775,8 +779,12 @@ size_t manifold_meshgl64_num_run(ManifoldMeshGL64* m) {
   return from_c(m)->NumRun();
 }
 
-void manifold_meshgl64_update_normals(ManifoldMeshGL64* m, int normal_idx) {
-  from_c(m)->UpdateNormals(normal_idx);
+int manifold_meshgl64_backside(ManifoldMeshGL64* m, size_t run) {
+  return from_c(m)->Backside(run) ? 1 : 0;
+}
+
+int manifold_meshgl64_has_normals(ManifoldMeshGL64* m, size_t run) {
+  return from_c(m)->HasNormals(run) ? 1 : 0;
 }
 
 ManifoldManifold* manifold_as_original(void* mem, ManifoldManifold* m) {
 
@@ -324,10 +324,10 @@ NB_MODULE(manifold3d, m) {
            nb::arg("endpoint"),
            "Cast a ray segment, returning all hits sorted by distance.")
       .def("calculate_normals", &Manifold::CalculateNormals,
-           nb::arg("normal_idx"), nb::arg("min_sharp_angle") = 60,
+           nb::arg("normal_idx") = 0, nb::arg("min_sharp_angle") = 60,
            manifold__calculate_normals__normal_idx__min_sharp_angle)
       .def("smooth_by_normals", &Manifold::SmoothByNormals,
-           nb::arg("normal_idx"), manifold__smooth_by_normals__normal_idx)
+           nb::arg("normal_idx") = 0, manifold__smooth_by_normals__normal_idx)
       .def("smooth_out", &Manifold::SmoothOut, nb::arg("min_sharp_angle") = 60,
            nb::arg("min_smoothness") = 0,
            manifold__smooth_out__min_sharp_angle__min_smoothness)
@@ -610,6 +610,8 @@ NB_MODULE(manifold3d, m) {
       .def_ro("run_original_id", &MeshGL::runOriginalID)
       .def_ro("run_flags", &MeshGL::runFlags)
       .def_ro("face_id", &MeshGL::faceID)
+      .def("backside", &MeshGL::Backside, nb::arg("run"))
+      .def("has_normals", &MeshGL::HasNormals, nb::arg("run"))
       .def("merge", &MeshGL::Merge, mesh_gl__merge);
 
   nb::class_<MeshGL64>(m, "Mesh64")
@@ -723,6 +725,8 @@ NB_MODULE(manifold3d, m) {
       .def_ro("run_original_id", &MeshGL64::runOriginalID)
       .def_ro("run_flags", &MeshGL64::runFlags)
       .def_ro("face_id", &MeshGL64::faceID)
+      .def("backside", &MeshGL64::Backside, nb::arg("run"))
+      .def("has_normals", &MeshGL64::HasNormals, nb::arg("run"))
       .def("merge", &MeshGL64::Merge, mesh_gl__merge);
 
   nb::class_<RayHit>(m, "RayHit")
 
@@ -180,7 +180,7 @@ EMSCRIPTEN_BINDINGS(whatever) {
       .function("refine", &Manifold::Refine)
       .function("refineToLength", &Manifold::RefineToLength)
       .function("refineToTolerance", &Manifold::RefineToTolerance)
-      .function("smoothByNormals", &Manifold::SmoothByNormals)
+      .function("_SmoothByNormals", &Manifold::SmoothByNormals)
       .function("_SmoothOut", &Manifold::SmoothOut)
       .function("_Warp", &man_js::Warp)
       .function("_WarpBatch", &man_js::WarpBatch)
 
@@ -252,10 +252,14 @@ Module.setup = function() {
   };
 
   Module.Manifold.prototype.calculateNormals = function(
-      normalIdx, minSharpAngle = 60) {
+      normalIdx = 0, minSharpAngle = 60) {
     return this._CalculateNormals(normalIdx, minSharpAngle);
   };
 
+  Module.Manifold.prototype.smoothByNormals = function(normalIdx = 0) {
+    return this._SmoothByNormals(normalIdx);
+  };
+
   Module.Manifold.prototype.setProperties = function(numProp, func) {
     const oldNumProp = this.numProp();
     const wasmFuncPtr = addFunction(function(newPtr, vec3Ptr, oldPtr) {
@@ -447,6 +451,16 @@ Module.setup = function() {
       mat4[15] = 1;
       return mat4;
     }
+
+    backside(run) {
+      return this.runFlags != null && run < this.runFlags.length &&
+          (this.runFlags[run] & 1) !== 0;
+    }
+
+    hasNormals(run) {
+      return this.runFlags != null && run < this.runFlags.length &&
+          (this.runFlags[run] & 2) !== 0;
+    }
   }
 
   Module.Mesh = Mesh;
 
@@ -739,10 +739,12 @@ export class Manifold {
    *
    * @param normalIdx The first property channel of the normals. NumProp must be
    * at least normalIdx + 3. Any vertex where multiple normals exist and don't
-   * agree will result in a sharp edge.
+   * agree will result in a sharp edge. Default is 0, the standard slot.
+   * Non-zero values are retained for compatibility and will not be supported
+   * in a future release.
    * @group Smoothing
    */
-  smoothByNormals(normalIdx: number): Manifold;
+  smoothByNormals(normalIdx?: number): Manifold;
 
   /**
    * Smooths out the Manifold by filling in the halfedgeTangent vectors. The
@@ -846,10 +848,13 @@ export class Manifold {
    * Fills in vertex properties for normal vectors, calculated from the mesh
    * geometry. Flat faces composed of three or more triangles will remain flat.
    *
-   * @param normalIdx The property channel in which to store the X
-   * values of the normals. The X, Y, and Z channels will be sequential. The
-   * property set will be automatically expanded to include up through normalIdx
-   * + 2.
+   * @param normalIdx The property channel in which to store the X values of the
+   * normals. The X, Y, and Z channels will be sequential. The property set will
+   * be automatically expanded to include up through normalIdx + 2. Default is
+   * 0, the standard slot; in that case the Manifold records the recording so
+   * a subsequent getMesh() without an explicit normalIdx returns solid-frame
+   * normals. Non-zero values are retained for compatibility and will not be
+   * supported in a future release.
    *
    * @param minSharpAngle Any edges with angles greater than this value will
    * remain sharp, getting different normal vector properties on each side of
@@ -859,7 +864,7 @@ export class Manifold {
    * all.
    * @group Properties
    */
-  calculateNormals(normalIdx: number, minSharpAngle?: number): Manifold;
+  calculateNormals(normalIdx?: number, minSharpAngle?: number): Manifold;
 
   // Boolean Operations
 
@@ -1336,6 +1341,14 @@ export class Mesh {
    */
   runTransform: Float32Array;
 
+  /**
+   * Optional: For each run, a bitmask of flags. Bit 0 = backside (this run
+   * is on the backside of its original mesh, e.g. from a subtraction).
+   * Bit 1 = hasNormals (the first three extra-property channels of this run
+   * hold world-frame vertex normals). See `backside(run)` / `hasNormals(run)`.
+   */
+  runFlags: Uint8Array;
+
   /**
    * Optional: Length NumTri, contains the source face ID this triangle comes
    * from. Simplification will maintain all edges between triangles with
@@ -1429,4 +1442,31 @@ export class Mesh {
    * @param run triangle run index.
    */
   transform(run: number): Mat4;
+
+  /**
+   * Returns true if this triangle run is on the backside compared to the
+   * original mesh, e.g. from a subtraction. Informational only - the
+   * framework already orients stored normals so the standard `getMesh()`
+   * flow returns world-frame values regardless of this bit.
+   *
+   * @param run triangle run index.
+   */
+  backside(run: number): boolean;
+
+  /**
+   * Returns true if the first three extra-property channels of this run
+   * carry world-frame vertex normals (set by `calculateNormals(0)` and
+   * round-tripped via `runFlags` bit 1). Consumers should treat the slot
+   * as normals and skip re-applying `runTransform` to it.
+   *
+   * hasNormals is per-run, so different runs may set it differently.
+   * Behavior is undefined when a single propVert is shared by triangles
+   * from runs that disagree - the slot has one interpretation, and a
+   * transform rotates it for hasNormals=true and clobbers any
+   * hasNormals=false sharer. Standard `calculateNormals` / boolean /
+   * compose outputs never produce that shape.
+   *
+   * @param run triangle run index.
+   */
+  hasNormals(run: number): boolean;
 }
@@ -245,7 +245,7 @@ class Manifold {
       int numProp,
       std::function<void(double*, vec3, const double*)> propFunc) const;
   Manifold CalculateCurvature(int gaussianIdx, int meanIdx) const;
-  Manifold CalculateNormals(int normalIdx, double minSharpAngle = 60) const;
+  Manifold CalculateNormals(int normalIdx = 0, double minSharpAngle = 60) const;
   ///@}
 
   /** @name Smoothing
@@ -256,7 +256,7 @@ class Manifold {
   Manifold Refine(int) const;
   Manifold RefineToLength(double) const;
   Manifold RefineToTolerance(double) const;
-  Manifold SmoothByNormals(int normalIdx) const;
+  Manifold SmoothByNormals(int normalIdx = 0) const;
   Manifold SmoothOut(double minSharpAngle = 60, double minSmoothness = 0) const;
   static Manifold Smooth(const MeshGL&,
                          const std::vector<Smoothness>& sharpenedEdges = {});
 
@@ -157,17 +157,6 @@ struct MeshGLP {
 
   MeshGLP() = default;
 
-  /**
-   * Updates the normals of the mesh based on the runTransform matrices and
-   * backside flags, which are then cleared to avoid double-applying them when
-   * round-tripping.
-   *
-   * @param normalIdx Specifies the first of the three consecutive property
-   * channels forming the (x, y, z) normals to update. NumProp must be at least
-   * normalIdx + 3 and normalIdx must be >= 3.
-   */
-  void UpdateNormals(int normalIdx);
-
   /**
    * Updates the mergeFromVert and mergeToVert vectors in order to create a
    * manifold solid. If the MeshGL is already manifold, no change will occur
@@ -235,13 +224,34 @@ struct MeshGLP {
 
   /**
    * Returns true if this triangle run is on the backside compared to the
-   * original mesh, e.g. from a subtraction. In this case vertex normals will
-   * need to be flipped. UpdateNormals() will take care of this.
+   * original mesh, e.g. from a subtraction. Informational only - the framework
+   * already orients stored normals so the standard `getMesh()` flow returns
+   * world-frame values regardless of this bit.
    *
    * @param run The index of the triangle run (0 <= run < runFlags.size()).
    */
   bool Backside(size_t run) const {
-    return run < runFlags.size() && runFlags[run] == 1;
+    return run < runFlags.size() && (runFlags[run] & 1) != 0;
+  }
+
+  /**
+   * Returns true if the first three extra-property channels (slots 3, 4, 5)
+   * of this run carry world-frame vertex normals (set by
+   * `Manifold::CalculateNormals(0)` and round-tripped via `runFlags` bit 1).
+   * Consumers should treat the slot as normals and skip re-applying
+   * `runTransform` to it.
+   *
+   * hasNormals is per-run, so different runs may set it differently.
+   * Behavior is undefined when a single propVert is shared by triangles
+   * from runs that disagree - the slot has one interpretation, and a
+   * Transform rotates it for hasNormals=true and clobbers any
+   * hasNormals=false sharer. Standard `CalculateNormals` / Boolean /
+   * Compose outputs never produce that shape.
+   *
+   * @param run The index of the triangle run (0 <= run < runFlags.size()).
+   */
+  bool HasNormals(size_t run) const {
+    return run < runFlags.size() && (runFlags[run] & 2) != 0;
   }
 };
 
 
@@ -569,7 +569,8 @@ struct Barycentric {
 };
 
 void CreateProperties(Manifold::Impl& outR, const Manifold::Impl& inP,
-                      const Manifold::Impl& inQ, ExecutionContext::Impl* ctx) {
+                      const Manifold::Impl& inQ, bool invertQ,
+                      ExecutionContext::Impl* ctx) {
   ZoneScoped;
   // Invariant: every ctx-passing parallel op is followed by IsCancelled to
   // keep partial output from feeding unconditional downstream consumers.
@@ -608,6 +609,15 @@ void CreateProperties(Manifold::Impl& outR, const Manifold::Impl& inP,
     const auto& properties = PQ ? inP.properties_ : inQ.properties_;
     const auto& halfedge = PQ ? inP.halfedge_ : inQ.halfedge_;
 
+    // For Subtract, Q's triangles are flipped in the result, so Q's
+    // world-frame vertex normals (slot 0..2 when hasNormals) need a sign
+    // flip to point outward from the result's solid (into the cavity).
+    // Check is per-source-triangle, not whole input - inQ may be a mixed
+    // Boolean result.
+    const bool negateNormals =
+        !PQ && invertQ && oldNumProp >= 3 &&
+        Manifold::Impl::TriHasNormals(inQ.meshRelation_, ref.faceID);
+
     for (const int i : {0, 1, 2}) {
       const int vert = outR.halfedge_.Start(3 * tri + i);
       const vec3& uvw = bary[3 * tri + i];
@@ -665,7 +675,9 @@ void CreateProperties(Manifold::Impl& outR, const Manifold::Impl& inP,
           for (const int j : {0, 1, 2})
             oldProps[j] =
                 properties[oldNumProp * halfedge.Prop(3 * ref.faceID + j) + p];
-          outR.properties_.push_back(la::dot(uvw, oldProps));
+          double val = la::dot(uvw, oldProps);
+          if (negateNormals && p < 3) val = -val;
+          outR.properties_.push_back(val);
         } else {
           outR.properties_.push_back(0);
         }
@@ -936,7 +948,7 @@ Manifold::Impl Boolean3::Result(OpType op) const {
     DEBUG_ASSERT(outR.IsManifold(), logicErr,
                  "triangulated mesh is not manifold!");
 
-  CreateProperties(outR, inP_, inQ_, ctx_);
+  CreateProperties(outR, inP_, inQ_, invertQ, ctx_);
   if (auto c = phase()) return *c;
 
   UpdateReference(outR, inP_, inQ_, invertQ, ctx_);
 
@@ -314,6 +314,18 @@ std::shared_ptr<CsgLeafNode> CsgLeafNode::Compose(
                 newProp.end(), numPropOut);
             copy(oldRange.begin(), oldRange.end(), newRange.begin());
           }
+          // Properties copy above doesn't go through the on-the-fly transform
+          // applied to vertPos_/faceNormal_ below; eager-transform slot 0..2
+          // per-meshID so world-frame normals stay in sync. Covers mixed
+          // input nodes (some meshIDs with hasNormals, some without).
+          if (numProp >= 3 && node->transform_ != mat3x4(la::identity)) {
+            const mat3 normalTransform =
+                la::inverse(la::transpose(mat3(node->transform_)));
+            Manifold::Impl::EagerTransformPropNormals(
+                node->pImpl_->halfedge_, node->pImpl_->meshRelation_,
+                normalTransform, newProp, oldProp.size() / numProp, numPropOut,
+                propVertIndices[i]);
+          }
         }
 
         if (node->transform_ == mat3x4(la::identity)) {