openscad-cpp-evaluator 1.25.0__tar.gz → 1.27.0__tar.gz

{openscad_cpp_evaluator-1.25.0 → openscad_cpp_evaluator-1.27.0}/CLAUDE.md

@@ -1135,6 +1135,12 @@ grep for `ponytail:`.
   `writeSvg`, which needs the sections that step throws away, and which says so rather than writing
   the slab's outline. `tools/cli/cli_lib.cpp` is the only current caller; a future GUI/renderer
   caller needs the same call before passing results to its own mesh consumer.
+  **The slab height is a parameter** (`flatHeight`, default `kTopLevel2dHeight` = 1.0, the
+  reference's measured preview height that docs images and `--viewall` framing depend on). Python
+  reaches it as `Evaluator(flat_preview_height=...)`, which thins only the DISPLAYED bodies:
+  `evaluate()` converts the raw list a second time at 1.0 for `geometry`, because a 2D-only script
+  exports its slab and that must not become whatever a viewer found easiest to look at. BelfrySCAD's
+  viewport asks for 0.01 so a 2D shape reads as the flat contour it is.
 - `include/openscad_cpp_evaluator/function_builtins.hpp`, `src/builtins/function_builtins.cpp` —
   the math/string/list/type-check builtin *function* dispatch (`isBuiltinFunctionName`/
   `evalBuiltinFunction`), a completely separate namespace/table from `dispatch.hpp`'s builtin
@@ -1687,6 +1693,20 @@ the former is worth dragging.
 A cache hit restamps to the chain reaching the geometry *now*, not the one that
 first produced it: a module called twice genuinely is two call chains.
 
+**A 2D shape is picked by `ColoredBody::sectionId`.** A `CrossSection` is contours
+with no run IDs, so a top-level 2D shape had no `idToNode` entry at all: its preview
+slab got fresh IDs from `Manifold::Extrude` in `toRenderableBodies`, after the table
+was built, and a click on it mapped to no source (it blocked BelfrySCAD's extrude
+gizmo, which exists to act on exactly those). Now the generate loop calls
+`tagSections` after every builtin's `GenerateFn`: any 2D body without an ID gets one
+reserved from Manifold's counter, attributed to that node. A transform keeps the ID
+it was given (it edits the body in place), so a 2D shape stays its primitive, as a
+solid's runs do; an op that builds a *new* section -- a 2D `union()`, `offset()`,
+`hull()` -- claims it, so the whole union is one pick. `restampCachedIds` restamps it
+by the solid rule (across renders, to the reused node), `recordRunColors` records its
+colour, and `toRenderableBodies` rebuilds the slab from a `MeshGL` whose one run
+carries it. Tested in `tests/test_python_bindings.py` (`_picked_text`).
+
 No stored script path is needed to tell the user's file from a library:
 `callStack_.front()` is by construction the call made from top level.
 
@@ -1695,7 +1715,7 @@ Exposed to Python as `node.call_sites` (innermost-first `_CallFrame`s, each a
 
 `Evaluator::measuring_` is set for the whole generate. It suppresses the four
 writes that exist solely to describe *drawn* geometry — `idToNode`/`idToColor`/`idToCallChain` in
-`tagGenerated` and `tagDisplayOnly`, the `restampCachedIds` call on a cache hit,
+`tagGenerated`, `tagDisplayOnly` and `tagSections`, the `restampCachedIds` call on a cache hit,
 and `cacheProducer_` — because those tables are cleared once per pass, so a leak
 is permanent and surfaces later as wrong click-to-source. It also suppresses
 `checkDebug`, which would otherwise inject stops at the paused statement's own

{openscad_cpp_evaluator-1.25.0 → openscad_cpp_evaluator-1.27.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscad_cpp_evaluator
-Version: 1.25.0
+Version: 1.27.0
 Summary: C++ OpenSCAD evaluator with Python bindings
 Author: NeuSCAD Contributors
 License-Expression: MIT

{openscad_cpp_evaluator-1.25.0 → openscad_cpp_evaluator-1.27.0}/bindings/module.cpp

@@ -505,10 +505,15 @@ nb::object coverageResultToPy(const std::optional<oscadeval::CoverageResult>& cr
 
 nb::object evaluate(const std::string& path, nb::dict viewportParams,
                      std::shared_ptr<oscadeval::ManifoldCache> manifoldCache, bool profile,
-                     bool generate, bool strictCommas, bool coverage, bool keepMinuendColor) {
+                     bool generate, bool strictCommas, bool coverage, bool keepMinuendColor,
+                     double flatPreviewHeight) {
     std::unordered_map<std::string, oscadeval::Value> vp = toViewportParams(viewportParams);
 
     std::vector<oscadeval::ColoredBody> bodies;
+    // What export gets. The same list as `bodies` unless the caller asked
+    // for a thinner preview slab: a 2D-only script exports its slab, and
+    // that must stay the reference's 1 unit whatever the viewer shows.
+    std::vector<oscadeval::ColoredBody> exportBodies;
     std::vector<std::string> echoes;
     std::vector<IdSpan> idSpans;
     std::vector<std::unique_ptr<oscadeval::CSGNode>> csgTree;
@@ -532,7 +537,10 @@ nb::object evaluate(const std::string& path, nb::dict viewportParams,
             ev.keepMinuendColor = keepMinuendColor;
             ev.setUsedFileGlobals(used.usedFileGlobals);
             oscadeval::EvalContext ctx = oscadeval::EvalContext::makeRoot(used.rootScope.get());
-            bodies = oscadeval::toRenderableBodies(ev.evaluate(used.processedNodes, ctx, vp, generate));
+            std::vector<oscadeval::ColoredBody> raw = ev.evaluate(used.processedNodes, ctx, vp, generate);
+            bodies = oscadeval::toRenderableBodies(raw, flatPreviewHeight);
+            exportBodies = flatPreviewHeight == oscadeval::kTopLevel2dHeight
+                               ? bodies : oscadeval::toRenderableBodies(raw);
             collectIdSpans(ev, idSpans);
             // Only moved out when it will actually be converted below --
             // csgTreeToPy() walks the whole tree building Python objects,
@@ -567,8 +575,8 @@ nb::object evaluate(const std::string& path, nb::dict viewportParams,
     nb::list echoList;
     for (const std::string& s : echoes) echoList.append(s);
     auto geom = std::make_shared<Geometry>();
-    geom->bodies = std::move(bodies);
-    return nb::make_tuple(bodiesToList(geom->bodies), echoList, idSpansToDict(idSpans), csgTreeToPy(csgTree),
+    geom->bodies = std::move(exportBodies);
+    return nb::make_tuple(bodiesToList(bodies), echoList, idSpansToDict(idSpans), csgTreeToPy(csgTree),
                            profileResultToPy(profileResult), dyn, dynExplicit, geom, coverageResultToPy(coverageResult));
 }
 
@@ -780,7 +788,7 @@ void callPyReturnHook(nb::handle returnHook, const std::string& name, const osca
 nb::object debugEvaluate(const std::string& path, nb::dict viewportParams, nb::callable debugHook,
                           nb::callable errorBreak, nb::callable echoFn,
                           std::shared_ptr<oscadeval::ManifoldCache> manifoldCache, nb::object returnHook,
-                          FastContinueSignal* fastContinueSignal) {
+                          FastContinueSignal* fastContinueSignal, double flatPreviewHeight) {
     std::unordered_map<std::string, oscadeval::Value> vp = toViewportParams(viewportParams);
 
     std::vector<oscadeval::ColoredBody> bodies;
@@ -841,7 +849,7 @@ nb::object debugEvaluate(const std::string& path, nb::dict viewportParams, nb::c
             if (fastContinueSignal) ev.setFastContinueInterruptFlag(fastContinueSignal->flag());
             ev.setUsedFileGlobals(used.usedFileGlobals);
             oscadeval::EvalContext ctx = oscadeval::EvalContext::makeRoot(used.rootScope.get());
-            bodies = oscadeval::toRenderableBodies(ev.evaluate(used.processedNodes, ctx, vp));
+            bodies = oscadeval::toRenderableBodies(ev.evaluate(used.processedNodes, ctx, vp), flatPreviewHeight);
             collectIdSpans(ev, idSpans);
             {
                 nb::gil_scoped_acquire g;
@@ -985,6 +993,7 @@ NB_MODULE(_openscad_cpp_evaluator, m) {
     m.def("evaluate", &evaluate, nb::arg("path"), nb::arg("viewport_params"), nb::arg("manifold_cache") = nullptr,
           nb::arg("profile") = false, nb::arg("generate") = true, nb::arg("strict_commas") = false,
           nb::arg("coverage") = false, nb::arg("keep_minuend_color") = false,
+          nb::arg("flat_preview_height") = oscadeval::kTopLevel2dHeight,
           "Evaluate a .scad file; return (bodies, echoes, id_to_node, csg_tree, profile_result, dyn, dyn_explicit, "
           "geometry, coverage_result).\n"
           "coverage=True records which statements, branch arms and bodies ran: coverage_result is a dict "
@@ -1024,5 +1033,6 @@ NB_MODULE(_openscad_cpp_evaluator, m) {
     m.def("debug_evaluate", &debugEvaluate, nb::arg("path"), nb::arg("viewport_params"), nb::arg("debug_hook"),
           nb::arg("error_break"), nb::arg("echo_fn"), nb::arg("manifold_cache") = nullptr,
           nb::arg("return_hook") = nb::none(), nb::arg("fast_continue_signal") = nullptr,
+          nb::arg("flat_preview_height") = oscadeval::kTopLevel2dHeight,
           "Evaluate with the debugger wired in; returns (bodies, [], id_to_node, dyn, dyn_explicit). Callbacks fire under the GIL.");
 }

{openscad_cpp_evaluator-1.25.0 → openscad_cpp_evaluator-1.27.0}/include/openscad_cpp_evaluator/colored_body.hpp

@@ -42,6 +42,15 @@ struct ColoredBody {
     std::optional<manifold::CrossSection> section;
     bool flatPreview = false;
 
+    // The originalID a 2D `section` is picked by. A CrossSection is contours
+    // and carries no run IDs, so a 2D shape had no entry in idToNode and a
+    // click on its preview slab mapped to no source at all. Reserved from
+    // Manifold's own counter (so it cannot collide with a solid's ID) by the
+    // generate loop, for the node that built the section -- a primitive, or
+    // an op like union() that made a new one; a transform keeps the one it
+    // was given. toRenderableBodies() gives the slab this ID.
+    std::optional<uint32_t> sectionId;
+
     // What a 2D `section` has been transformed BY that a CrossSection
     // cannot itself hold: a translation along Z, a rotation out of the XY
     // plane, anything with a Z component. Applied when
@@ -160,6 +169,13 @@ std::optional<std::array<float, 4>> valueToColor(const Value& v);
 // (the CLI, any other mesh-export caller) should apply this to
 // Evaluator::evaluate()'s result before exporting, the same way the
 // reference's own cli.py does right before export_bodies().
-std::vector<ColoredBody> toRenderableBodies(const std::vector<ColoredBody>& bodies);
+// The thickness toRenderableBodies() gives a top-level 2D shape's slab by
+// default: OpenSCAD's own preview height, measured (see colored_body.cpp).
+// Docs images and exports use it; an interactive viewer may pass a thinner
+// one so a 2D shape reads as the flat contour it is.
+inline constexpr double kTopLevel2dHeight = 1.0;
+
+std::vector<ColoredBody> toRenderableBodies(const std::vector<ColoredBody>& bodies,
+                                            double flatHeight = kTopLevel2dHeight);
 
 } // namespace oscadeval

{openscad_cpp_evaluator-1.25.0 → openscad_cpp_evaluator-1.27.0}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -283,6 +283,9 @@ public:
     // attributes there).
     // Give cached bodies fresh originalIDs so a second call site reusing
     // them is not confused with the first. See its definition.
+    // Give every 2D body in `bodies` that has no sectionId yet one of its
+    // own, attributed to `node`. See ColoredBody::sectionId.
+    void tagSections(std::vector<ColoredBody>& bodies, const oscad::ASTNode& node, uint32_t callChain);
     void restampCachedIds(std::vector<ColoredBody>& bodies, const oscad::ASTNode& node,
                           const oscad::ASTNode* producer, uint32_t callChain);
 

{openscad_cpp_evaluator-1.25.0 → openscad_cpp_evaluator-1.27.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "openscad_cpp_evaluator"
-version = "1.25.0"
+version = "1.27.0"
 description = "C++ OpenSCAD evaluator with Python bindings"
 readme = "README.md"
 requires-python = ">=3.12"

{openscad_cpp_evaluator-1.25.0 → openscad_cpp_evaluator-1.27.0}/python/openscad_cpp_evaluator/__init__.py

@@ -565,7 +565,7 @@ class Evaluator:
 
     def __init__(self, echo_fn=None, debug_hook=None, error_break_fn=None, return_hook=None,
                  manifold_cache=None, profile=False, fast_continue_signal=None, coverage=False,
-                 keep_minuend_color=False):
+                 keep_minuend_color=False, flat_preview_height=1.0):
         self._echo_fn = echo_fn
         self._debug_hook = debug_hook
         self._error_break_fn = error_break_fn
@@ -579,6 +579,12 @@ class Evaluator:
         # subtrahend's (or the cut green). A viewer option; see
         # Evaluator::keepMinuendColor in evaluator.hpp.
         self._keep_minuend_color = keep_minuend_color
+        # How thick a top-level 2D shape's preview slab is in the returned
+        # bodies. 1.0 is OpenSCAD's preview height, which docs images and
+        # --viewall framing depend on; a viewer can pass something thin so
+        # a 2D shape reads as a flat contour. Export (`geometry`) always
+        # keeps 1.0: a 2D-only script exports its slab.
+        self._flat_preview_height = float(flat_preview_height)
         self.csg_tree = []
         self.profile_result = None
         # coverage=True: after evaluate(), {"spans": [...], "files": [...],
@@ -621,7 +627,8 @@ class Evaluator:
                     source_path, vp, self._debug_hook,
                     self._error_break_fn or (lambda *a, **k: None),
                     self._echo_fn or (lambda _m: None),
-                    self._manifold_cache, self._return_hook, self._fast_continue_signal)
+                    self._manifold_cache, self._return_hook, self._fast_continue_signal,
+                    self._flat_preview_height)
                 self.csg_tree = []
                 self.profile_result = None
                 # The debugger path has no geometry handle: debug_evaluate
@@ -632,7 +639,8 @@ class Evaluator:
                 (body_dicts, echoes, id_spans, csg_tree, profile_result, dyn,
                  dyn_explicit, geometry, coverage_result) = _ext.evaluate(
                     source_path, vp, self._manifold_cache, self._profile, generate,
-                    strict_commas, self._coverage, self._keep_minuend_color)
+                    strict_commas, self._coverage, self._keep_minuend_color,
+                    self._flat_preview_height)
                 # The evaluated bodies, still on the C++ side. Stashed like
                 # csg_tree/profile_result rather than returned, so
                 # evaluate()'s own 2-tuple result is unchanged -- callers

{openscad_cpp_evaluator-1.25.0 → openscad_cpp_evaluator-1.27.0}/src/colored_body.cpp

@@ -20,23 +20,33 @@ std::optional<std::array<float, 4>> valueToColor(const Value& v) {
     return c;
 }
 
-namespace {
-// The reference extrudes a 2D shape to exactly 1 unit for preview -- measured
+// kTopLevel2dHeight (colored_body.hpp), the default slab height: the
+// reference extrudes a 2D shape to exactly 1 unit for preview -- measured
 // against OpenSCAD at three camera tilts (60/70/80 degrees), which put it at
 // 0.92/1.00/0.99, the 60 being pixel-rounding on the shallowest angle. Ours
 // was 1e-3, which reads as a flat silhouette with no visible edge and, more
 // annoyingly, gives --viewall a different bounding box to fit, so every 2D
 // docs image came out at a different scale from the published one.
-constexpr double kTopLevel2dHeight = 1.0;
-} // namespace
 
-std::vector<ColoredBody> toRenderableBodies(const std::vector<ColoredBody>& bodies) {
+std::vector<ColoredBody> toRenderableBodies(const std::vector<ColoredBody>& bodies, double flatHeight) {
     std::vector<ColoredBody> out;
     out.reserve(bodies.size());
     for (const ColoredBody& cb : bodies) {
         if (!cb.body && cb.section) {
             ColoredBody flat;
-            flat.body = manifold::Manifold::Extrude(cb.section->ToPolygons(), kTopLevel2dHeight);
+            flat.body = manifold::Manifold::Extrude(cb.section->ToPolygons(), flatHeight);
+            if (cb.sectionId && !flat.body->IsEmpty()) {
+                // One run carrying the section's own ID, so a click on the
+                // slab finds the node that built the shape (see
+                // ColoredBody::sectionId). Manifold keeps a MeshGL's
+                // runOriginalID when it is given one.
+                manifold::MeshGL mesh = flat.body->GetMeshGL();
+                mesh.runOriginalID = {*cb.sectionId};
+                mesh.runIndex = {0, static_cast<uint32_t>(mesh.triVerts.size())};
+                mesh.runTransform.clear();
+                mesh.faceID.clear();
+                flat.body = manifold::Manifold(mesh);
+            }
             // Put it back where the transforms a CrossSection could not
             // hold would have placed it -- a Z offset, a rotation out of
             // the plane. See ColoredBody::sectionXform.

{openscad_cpp_evaluator-1.25.0 → openscad_cpp_evaluator-1.27.0}/src/csg_generate.cpp

@@ -124,6 +124,7 @@ std::vector<ColoredBody> Evaluator::generateTreeImpl(const std::vector<CSGNode*>
                 generateWarnEntry = node.warnEntry;
                 generateCallChain = node.callChain;
                 node.bodies = it->second(*this, node.params, node.children, *node.node);
+                if (!measuring_) tagSections(node.bodies, *node.node, node.callChain);
                 generateWarnEntry = savedWarnEntry;
                 generateCallChain = savedCallChain;
             } else {
@@ -393,6 +394,16 @@ void Evaluator::restampCachedIds(std::vector<ColoredBody>& bodies, const oscad::
     // its producer check keeps the first copy's descendants. They occupy
     // the same space, so there is nothing to select apart.
     for (ColoredBody& cb : bodies) {
+        // A 2D body's one ID, restamped by the same rule as a solid's runs.
+        if (cb.sectionId) {
+            const uint32_t fresh = manifold::Manifold::ReserveIDs(1);
+            auto old = idToNode.find(*cb.sectionId);
+            idToNode[fresh] =
+                (old != idToNode.end() && old->second != producer) ? old->second : &node;
+            idToCallChain[fresh] = callChain;
+            idToColor[fresh] = cb.color;
+            cb.sectionId = fresh;
+        }
         if (!cb.body || cb.body->IsEmpty()) continue;
         manifold::MeshGL mesh = cb.body->GetMeshGL();
         if (mesh.runOriginalID.empty()) continue;
@@ -475,6 +486,7 @@ void Evaluator::restampCachedIds(std::vector<ColoredBody>& bodies, const oscad::
 
 
 void Evaluator::recordRunColors(ColoredBody& b, const std::optional<std::array<float, 4>>& rgba) {
+    if (b.sectionId) idToColor[*b.sectionId] = rgba;
     if (!b.body || bodyIsEmpty(b)) return;
     // A body that is still one original knows its own ID without building
     // a mesh -- the common case, and the cheap one.
@@ -486,6 +498,18 @@ void Evaluator::recordRunColors(ColoredBody& b, const std::optional<std::array<f
     for (uint32_t id : b.body->GetMeshGL().runOriginalID) idToColor[id] = rgba;
 }
 
+void Evaluator::tagSections(std::vector<ColoredBody>& bodies, const oscad::ASTNode& node,
+                            uint32_t callChain) {
+    for (ColoredBody& cb : bodies) {
+        if (!cb.section || cb.body || cb.sectionId) continue;
+        const uint32_t id = manifold::Manifold::ReserveIDs(1);
+        idToNode[id] = &node;
+        idToColor[id] = cb.color;
+        idToCallChain[id] = callChain;
+        cb.sectionId = id;
+    }
+}
+
 ColoredBody Evaluator::tagGenerated(manifold::Manifold body, const oscad::ASTNode& node, const Value& colorValue) {
     manifold::MeshGL mesh = body.GetMeshGL();
     std::optional<std::array<float, 4>> color = valueToColor(colorValue);

{openscad_cpp_evaluator-1.25.0 → openscad_cpp_evaluator-1.27.0}/tests/test_python_bindings.py

@@ -1046,3 +1046,78 @@ def test_svg_class_is_feature_detectable(tmp_path):
     out = []
     Evaluator(echo_fn=out.append).evaluate(str(scad), generate=False)
     assert "1" in out[0], out
+
+
+def _picked_text(tmp_path, src, cache=None, name="s.scad"):
+    """What a click on each body would select: the source text its run IDs
+    map to, per body, in body order."""
+    script = tmp_path / name
+    script.write_text(src)
+    ev = Evaluator(manifold_cache=cache) if cache else Evaluator()
+    bodies, id_to_node = ev.evaluate(str(script), {})
+    out = []
+    for b in bodies:
+        ids = [int(i) for i in b.body.to_mesh().run_original_id]
+        out.append([src[id_to_node[i].position.start_offset:id_to_node[i].position.end_offset]
+                    if i in id_to_node else None for i in ids])
+    return out
+
+
+def test_a_2d_shape_can_be_picked_back_to_its_source(tmp_path):
+    """A CrossSection carries no run IDs, so a 2D shape's preview slab used
+    to map to no node at all and could not be selected (BelfrySCAD's
+    extrude gizmo needs exactly that)."""
+    picked = _picked_text(tmp_path, "square(3);\ncircle(4);\n")
+    assert picked == [["square(3);"], ["circle(4);"]]
+
+
+def test_a_transform_keeps_the_2d_shape_it_moved(tmp_path):
+    picked = _picked_text(tmp_path, "translate([10, 0]) circle(4);\n")
+    assert len(picked) == 1 and picked[0][0] is not None
+    assert picked[0][0].startswith("circle(4)") or picked[0][0].startswith("translate")
+
+
+def test_a_2d_union_is_its_own_shape(tmp_path):
+    src = "union() { square(3); circle(4); }\n"
+    assert _picked_text(tmp_path, src) == [[src.strip()]]
+
+
+def test_a_cached_2d_shape_is_picked_as_a_solid_would_be(tmp_path):
+    """A cache hit restamps IDs; a 2D shape's must follow, or the second
+    render of an unchanged script loses every 2D selection. It follows the
+    same rule a solid's runs do: across renders the old ID is unknown, so it
+    goes to the reused node -- here the whole translate() statement."""
+    def two_renders(src):
+        cache = ManifoldCache()
+        return _picked_text(tmp_path, src, cache), _picked_text(tmp_path, src, cache)
+
+    flat = two_renders("square(3);\ntranslate([10, 0]) circle(4);\n")
+    solid = two_renders("cube(3);\ntranslate([10, 0, 0]) sphere(4);\n")
+    assert all(t is not None for render in flat for body in render for t in body)
+    assert flat[1] == [["square(3);"], ["translate([10, 0]) circle(4);"]]
+    assert solid[1] == [["cube(3);"], ["translate([10, 0, 0]) sphere(4);"]]
+
+
+def test_a_viewer_can_ask_for_a_thin_2d_slab_and_export_keeps_1(tmp_path):
+    """flat_preview_height thins the DISPLAYED slab only: a 2D-only script
+    exports that slab, and it has to stay the reference's 1 unit."""
+    import openscad_cpp_evaluator as E
+    script = tmp_path / "flat.scad"
+    script.write_text("square(10);\n")
+
+    def z_extent(bodies):
+        verts = bodies[0].body.to_mesh().vert_properties
+        return float(verts[:, 2].max() - verts[:, 2].min())
+
+    default = E.Evaluator()
+    assert abs(z_extent(default.evaluate(str(script), {})[0]) - 1.0) < 1e-9
+    thin = E.Evaluator(flat_preview_height=0.01)
+    bodies, id_to_node = thin.evaluate(str(script), {})
+    assert abs(z_extent(bodies) - 0.01) < 1e-9
+    assert id_to_node, "still pickable"
+    out = tmp_path / "flat.off"            # ASCII: header, counts, vertices
+    E.export_model(str(out), thin.geometry)
+    lines = [l for l in out.read_text().splitlines() if l.strip() and not l.startswith("#")]
+    nverts = int(lines[1].split()[0])
+    zs = [float(l.split()[2]) for l in lines[2:2 + nverts]]
+    assert abs(max(zs) - min(zs) - 1.0) < 1e-6, "export is the 1-unit slab"