carterkit 0.1.0__tar.gz → 0.2.0__tar.gz

{carterkit-0.1.0 → carterkit-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: carterkit
-Version: 0.1.0
+Version: 0.2.0
 Summary: Build and drive CAR-TER layouts from Python — the control docs are the library.
 Author: Carter Beaudoin
 License-Expression: MIT
@@ -51,23 +51,40 @@ carterkit.examples("button")    # documented example snippets
 
 ## Build a layout
 
+Use **typed builders** (`build.<control>`) and **binding helpers** (`bind`) — both
+generated from / shaped by the bundled docs, so unknown control types and bad enum
+values raise instead of silently shipping a broken layout:
+
 ```python
-from carterkit import LayoutBuffer, validate_layout
+import carterkit
+from carterkit import LayoutBuffer, build, bind, validate_layout
 
 b = LayoutBuffer.blank(name="Dashboard", columns=4, rows=4)
-b.add_control({"type": "gauge", "id": "cpu", "label": "CPU", "min": 0, "max": 100},
+b.add_control(build.gauge(id="cpu", label="CPU", min=0, max=100,
+                          sync=[bind.listen("cpu", filter={"msg_type": "metrics"})]),
               default_span=[2, 2])
-b.add_control({"type": "button", "id": "refresh", "label": "Refresh"})
+b.add_control(build.button(id="refresh", label="Refresh",
+                           action=bind.action("refresh")))
 
-layout = b.layout
-findings = validate_layout(layout)      # schema + grid lint against the bundled catalog
-print(carterkit.format_findings(findings))
+print(carterkit.format_findings(validate_layout(b.layout)))   # schema + grid lint
+help(build.gauge)        # ← prints the gauge documentation, straight from the docs
 ```
 
 `infer.build_layout(payload)` generates a wired layout from a sample telemetry dict;
 `codegen.generate_service_stub(layout)` emits a runnable MeshSocket server skeleton;
 `theming.theme_for(...)` and `tune.tune_gauge(...)` round out the authoring tools.
 
+## CLI
+
+```bash
+carterkit catalog                 # list every control type
+carterkit doc gauge               # print a control's documentation
+carterkit examples button         # list a control's examples (--name to print one)
+carterkit validate layout.json    # lint a layout (exit 1 on errors)
+carterkit gen layout.json         # generate a MeshSocket service stub
+carterkit relay --port 8765       # run the bundled MeshSocket relay
+```
+
 ## Drive a device
 
 ```python

{carterkit-0.1.0 → carterkit-0.2.0}/README.md

@@ -28,23 +28,40 @@ carterkit.examples("button")    # documented example snippets
 
 ## Build a layout
 
+Use **typed builders** (`build.<control>`) and **binding helpers** (`bind`) — both
+generated from / shaped by the bundled docs, so unknown control types and bad enum
+values raise instead of silently shipping a broken layout:
+
 ```python
-from carterkit import LayoutBuffer, validate_layout
+import carterkit
+from carterkit import LayoutBuffer, build, bind, validate_layout
 
 b = LayoutBuffer.blank(name="Dashboard", columns=4, rows=4)
-b.add_control({"type": "gauge", "id": "cpu", "label": "CPU", "min": 0, "max": 100},
+b.add_control(build.gauge(id="cpu", label="CPU", min=0, max=100,
+                          sync=[bind.listen("cpu", filter={"msg_type": "metrics"})]),
               default_span=[2, 2])
-b.add_control({"type": "button", "id": "refresh", "label": "Refresh"})
+b.add_control(build.button(id="refresh", label="Refresh",
+                           action=bind.action("refresh")))
 
-layout = b.layout
-findings = validate_layout(layout)      # schema + grid lint against the bundled catalog
-print(carterkit.format_findings(findings))
+print(carterkit.format_findings(validate_layout(b.layout)))   # schema + grid lint
+help(build.gauge)        # ← prints the gauge documentation, straight from the docs
 ```
 
 `infer.build_layout(payload)` generates a wired layout from a sample telemetry dict;
 `codegen.generate_service_stub(layout)` emits a runnable MeshSocket server skeleton;
 `theming.theme_for(...)` and `tune.tune_gauge(...)` round out the authoring tools.
 
+## CLI
+
+```bash
+carterkit catalog                 # list every control type
+carterkit doc gauge               # print a control's documentation
+carterkit examples button         # list a control's examples (--name to print one)
+carterkit validate layout.json    # lint a layout (exit 1 on errors)
+carterkit gen layout.json         # generate a MeshSocket service stub
+carterkit relay --port 8765       # run the bundled MeshSocket relay
+```
+
 ## Drive a device
 
 ```python

{carterkit-0.1.0 → carterkit-0.2.0}/carterkit/__init__.py

@@ -19,8 +19,10 @@ from . import catalog, grid, codegen, infer, theming, tune
 from .buffer import LayoutBuffer, BufferError
 from .validate import validate_layout as _validate_layout, format_findings
 from .client import CarterClient, notify_http, CarterNotifyError
+from . import bind
+from .controls import build, control
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"
 
 #: The layout/wire protocol version carterkit emits and understands. The JSON
 #: contract — not this Python API — is the real compatibility boundary across the
@@ -65,5 +67,6 @@ __all__ = [
     "LayoutBuffer", "BufferError",
     "controls", "doc", "doc_markdown", "examples", "validate_layout",
     "format_findings", "controldocs_dir",
+    "build", "control", "bind",
     "catalog", "grid", "codegen", "infer", "theming", "tune",
 ]

carterkit-0.2.0/carterkit/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

carterkit-0.2.0/carterkit/bind.py

@@ -0,0 +1,40 @@
+"""Helpers that build the (verbose, easy-to-get-wrong) sync / action / connection
+dicts controls use. Shapes mirror the bundled ControlDocs (sync.md, actions.md).
+
+    from carterkit import bind
+    bind.listen("cpu", filter={"msg_type": "telemetry"})
+    bind.action("set_power", payload={"state": "{{value}}"}, mode="request")
+    bind.connection("ws://192.168.1.50:8765", channel="home")
+"""
+from __future__ import annotations
+
+
+def listen(value_path: str, *, event: str = "broadcast", filter: dict | None = None,
+           method: str = "meshsocket") -> dict:
+    """A `sync` entry: subscribe to `event`, match `filter`, extract `value_path`
+    (dot-notation). Returns one sync dict — controls take a list of them."""
+    s: dict = {"method": method, "type": "listen", "event": event, "valuePath": value_path}
+    if filter is not None:
+        s["filter"] = filter
+    return s
+
+
+def action(event: str, *, payload: dict | None = None, mode: str = "broadcast",
+           method: str = "meshsocket") -> dict:
+    """An `action` dict: fire `event` on tap/change. `mode` is "broadcast" (fire and
+    forget) or "request" (await reply). `payload` strings support `{{value}}`."""
+    if mode not in ("broadcast", "request"):
+        raise ValueError(f"mode must be 'broadcast' or 'request', got {mode!r}")
+    a: dict = {"method": method, "mode": mode, "event": event}
+    if payload is not None:
+        a["payload"] = payload
+    return a
+
+
+def connection(url: str, *, channel: str = "home", name: str = "CAR-TER",
+               role: str = "controller", token: str | None = None) -> dict:
+    """A layout `connection` block (relay URL + identity)."""
+    conn: dict = {"url": url, "identity": {"name": name, "channel": channel, "role": role}}
+    if token is not None:
+        conn["token"] = token
+    return conn

carterkit-0.2.0/carterkit/cli.py

@@ -0,0 +1,128 @@
+"""Command-line interface: ``carterkit <command>`` (also ``python -m carterkit``).
+
+Commands: catalog · doc · examples · validate · gen · relay · version.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+
+
+def _cmd_catalog(args) -> int:
+    import carterkit
+    cat = carterkit.controls(types=[args.type] if args.type else None, include_theme=args.theme)
+    if args.json:
+        print(json.dumps(cat, indent=2))
+    else:
+        for t in sorted(cat):
+            spec = cat[t]
+            print(f"{t:18} {spec.get('label', ''):16} ({spec.get('category', '')})")
+    return 0
+
+
+def _cmd_doc(args) -> int:
+    import carterkit
+    md = carterkit.doc_markdown(args.control)
+    if md is None:
+        print(f"no doc for {args.control!r}", file=sys.stderr)
+        return 1
+    print(md)
+    return 0
+
+
+def _cmd_examples(args) -> int:
+    import carterkit
+    if args.name:
+        from carterkit import catalog, controldocs_dir
+        ex = catalog.find_example(controldocs_dir(), args.control, args.name)
+        if not ex:
+            print(f"no example {args.name!r} for {args.control!r}", file=sys.stderr)
+            return 1
+        print(ex["json"])
+        return 0
+    exs = carterkit.examples(args.control)
+    if not exs:
+        print(f"no examples for {args.control!r}", file=sys.stderr)
+        return 1
+    for ex in exs:
+        print("•", ex["name"])
+    return 0
+
+
+def _cmd_validate(args) -> int:
+    import carterkit
+    with open(args.file) as f:
+        layout = json.load(f)
+    findings = carterkit.validate_layout(layout)
+    print(carterkit.format_findings(findings))
+    return 1 if any(f["severity"] == "error" for f in findings) else 0
+
+
+def _cmd_gen(args) -> int:
+    import carterkit
+    with open(args.file) as f:
+        layout = json.load(f)
+    print(carterkit.codegen.generate_service_stub(layout))
+    return 0
+
+
+def _cmd_relay(args) -> int:
+    import asyncio
+    from socket_server import MeshServer  # bundled with meshsocket
+    print(f"MeshSocket relay on ws://{args.host}:{args.port}", file=sys.stderr)
+    asyncio.run(MeshServer(host=args.host, port=args.port).start())
+    return 0
+
+
+def _cmd_version(args) -> int:
+    import carterkit
+    print(carterkit.__version__)
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="carterkit", description="Build and drive CAR-TER layouts.")
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    c = sub.add_parser("catalog", help="list the control catalog")
+    c.add_argument("--type", help="restrict to one control type")
+    c.add_argument("--theme", action="store_true", help="include per-control theme fields")
+    c.add_argument("--json", action="store_true", help="emit machine-readable JSON")
+    c.set_defaults(fn=_cmd_catalog)
+
+    c = sub.add_parser("doc", help="print a control's documentation")
+    c.add_argument("control")
+    c.set_defaults(fn=_cmd_doc)
+
+    c = sub.add_parser("examples", help="list a control's examples, or print one with --name")
+    c.add_argument("control")
+    c.add_argument("--name", help="print the JSON of the named example")
+    c.set_defaults(fn=_cmd_examples)
+
+    c = sub.add_parser("validate", help="lint a layout JSON file (exit 1 on errors)")
+    c.add_argument("file")
+    c.set_defaults(fn=_cmd_validate)
+
+    c = sub.add_parser("gen", help="generate a MeshSocket service stub from a layout file")
+    c.add_argument("file")
+    c.set_defaults(fn=_cmd_gen)
+
+    c = sub.add_parser("relay", help="run the bundled MeshSocket relay")
+    c.add_argument("--host", default="0.0.0.0")
+    c.add_argument("--port", type=int, default=8765)
+    c.set_defaults(fn=_cmd_relay)
+
+    c = sub.add_parser("version", help="print the carterkit version")
+    c.set_defaults(fn=_cmd_version)
+
+    return p
+
+
+def main(argv=None) -> int:
+    args = build_parser().parse_args(argv)
+    return args.fn(args)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

carterkit-0.2.0/carterkit/controls.py

@@ -0,0 +1,90 @@
+"""Typed control constructors, generated at runtime from the bundled ControlDocs.
+
+Because the catalog *is* the docs, every placeable control type is available as a
+builder whose validation and `help()` come straight from its documentation:
+
+    from carterkit import build
+    build.gauge(id="cpu", min=0, max=100, sync=[bind.listen("cpu")])
+    build.color_picker(id="tint")             # snake_case maps to the catalog type
+    help(build.gauge)                          # prints the gauge documentation
+
+Unknown control types and bad enum values raise; unknown props are allowed
+(forward-compatible — the device ignores props it doesn't understand).
+"""
+from __future__ import annotations
+
+from functools import lru_cache
+
+from . import catalog
+
+
+@lru_cache(maxsize=1)
+def _catalog() -> dict:
+    from . import controldocs_dir
+    return catalog.build_catalog(controldocs_dir())
+
+
+def _resolve_type(name: str) -> str | None:
+    """Map an attribute name to a catalog control type: exact, or snake_case→camelCase."""
+    cat = _catalog()
+    if name in cat:
+        return name
+    head, *rest = name.split("_")
+    camel = head + "".join(p.title() for p in rest)
+    return camel if camel in cat else None
+
+
+def control(type: str, *, id: str, position=None, span=None, **props) -> dict:
+    """Build and validate one control dict. `id` is required; `position`/`span` are
+    optional. Raises on an unknown control type or an out-of-range enum value."""
+    cat = _catalog()
+    if type not in cat:
+        raise ValueError(f"unknown control type {type!r}. Known: {', '.join(sorted(cat))}")
+    spec = cat[type]
+    enums = {f["name"]: f["values"] for f in spec.get("fields", [])
+             if f.get("type") == "enum" and f.get("values")}
+    for key, val in props.items():
+        if key in enums and val not in enums[key]:
+            raise ValueError(
+                f"{type}.{key}={val!r} is not a valid option; choose one of {enums[key]}")
+    out: dict = {"type": type, "id": id}
+    if position is not None:
+        out["position"] = list(position)
+    if span is not None:
+        out["span"] = list(span)
+    out.update(props)
+    return out
+
+
+class _Controls:
+    """Attribute access returns a builder bound to a catalog control type."""
+
+    def __getattr__(self, name: str):
+        ctype = _resolve_type(name)
+        if ctype is None:
+            raise AttributeError(
+                f"no control type {name!r}. Available: {', '.join(self.__dir__())}")
+
+        def make(*, id: str, position=None, span=None, **props) -> dict:
+            return control(ctype, id=id, position=position, span=span, **props)
+
+        doc = catalog.resolve_doc(_catalog_dir(), ctype)
+        make.__name__ = ctype
+        make.__qualname__ = f"controls.{ctype}"
+        make.__doc__ = (doc or {}).get("body") or f"Build a {ctype} control."
+        return make
+
+    def __dir__(self):
+        return sorted(_catalog())
+
+    def types(self) -> list[str]:
+        """All placeable control types available as builders."""
+        return sorted(_catalog())
+
+
+def _catalog_dir():
+    from . import controldocs_dir
+    return controldocs_dir()
+
+
+build = _Controls()

{carterkit-0.1.0 → carterkit-0.2.0}/carterkit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: carterkit
-Version: 0.1.0
+Version: 0.2.0
 Summary: Build and drive CAR-TER layouts from Python — the control docs are the library.
 Author: Carter Beaudoin
 License-Expression: MIT
@@ -51,23 +51,40 @@ carterkit.examples("button")    # documented example snippets
 
 ## Build a layout
 
+Use **typed builders** (`build.<control>`) and **binding helpers** (`bind`) — both
+generated from / shaped by the bundled docs, so unknown control types and bad enum
+values raise instead of silently shipping a broken layout:
+
 ```python
-from carterkit import LayoutBuffer, validate_layout
+import carterkit
+from carterkit import LayoutBuffer, build, bind, validate_layout
 
 b = LayoutBuffer.blank(name="Dashboard", columns=4, rows=4)
-b.add_control({"type": "gauge", "id": "cpu", "label": "CPU", "min": 0, "max": 100},
+b.add_control(build.gauge(id="cpu", label="CPU", min=0, max=100,
+                          sync=[bind.listen("cpu", filter={"msg_type": "metrics"})]),
               default_span=[2, 2])
-b.add_control({"type": "button", "id": "refresh", "label": "Refresh"})
+b.add_control(build.button(id="refresh", label="Refresh",
+                           action=bind.action("refresh")))
 
-layout = b.layout
-findings = validate_layout(layout)      # schema + grid lint against the bundled catalog
-print(carterkit.format_findings(findings))
+print(carterkit.format_findings(validate_layout(b.layout)))   # schema + grid lint
+help(build.gauge)        # ← prints the gauge documentation, straight from the docs
 ```
 
 `infer.build_layout(payload)` generates a wired layout from a sample telemetry dict;
 `codegen.generate_service_stub(layout)` emits a runnable MeshSocket server skeleton;
 `theming.theme_for(...)` and `tune.tune_gauge(...)` round out the authoring tools.
 
+## CLI
+
+```bash
+carterkit catalog                 # list every control type
+carterkit doc gauge               # print a control's documentation
+carterkit examples button         # list a control's examples (--name to print one)
+carterkit validate layout.json    # lint a layout (exit 1 on errors)
+carterkit gen layout.json         # generate a MeshSocket service stub
+carterkit relay --port 8765       # run the bundled MeshSocket relay
+```
+
 ## Drive a device
 
 ```python

{carterkit-0.1.0 → carterkit-0.2.0}/carterkit.egg-info/SOURCES.txt

@@ -2,19 +2,25 @@ LICENSE
 README.md
 pyproject.toml
 carterkit/__init__.py
+carterkit/__main__.py
+carterkit/bind.py
 carterkit/buffer.py
 carterkit/catalog.py
+carterkit/cli.py
 carterkit/client.py
 carterkit/codegen.py
+carterkit/controls.py
 carterkit/e2ee.py
 carterkit/grid.py
 carterkit/infer.py
+carterkit/py.typed
 carterkit/theming.py
 carterkit/tune.py
 carterkit/validate.py
 carterkit.egg-info/PKG-INFO
 carterkit.egg-info/SOURCES.txt
 carterkit.egg-info/dependency_links.txt
+carterkit.egg-info/entry_points.txt
 carterkit.egg-info/requires.txt
 carterkit.egg-info/top_level.txt
 carterkit/controldocs/accordion.md
@@ -61,9 +67,12 @@ carterkit/controldocs/theming.md
 carterkit/controldocs/toggle.md
 carterkit/controldocs/visibility.md
 carterkit/controldocs/web-view.md
+tests/test_bind.py
 tests/test_buffer.py
 tests/test_catalog.py
+tests/test_cli.py
 tests/test_codegen.py
+tests/test_controls.py
 tests/test_e2ee.py
 tests/test_grid.py
 tests/test_infer.py

carterkit-0.2.0/carterkit.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+carterkit = carterkit.cli:main

{carterkit-0.1.0 → carterkit-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "carterkit"
-version = "0.1.0"
+version = "0.2.0"
 description = "Build and drive CAR-TER layouts from Python — the control docs are the library."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -30,8 +30,11 @@ classifiers = [
 Homepage = "https://github.com/Mariner10/carterkit"
 Repository = "https://github.com/Mariner10/carterkit"
 
+[project.scripts]
+carterkit = "carterkit.cli:main"
+
 [tool.setuptools]
 packages = ["carterkit"]
 
 [tool.setuptools.package-data]
-carterkit = ["controldocs/*.md"]
+carterkit = ["controldocs/*.md", "py.typed"]

carterkit-0.2.0/tests/test_bind.py

@@ -0,0 +1,40 @@
+"""Tests for bind.py — sync/action/connection helper shapes."""
+
+import pytest
+
+from carterkit import bind
+
+
+def test_listen_basic():
+    assert bind.listen("cpu") == {
+        "method": "meshsocket", "type": "listen", "event": "broadcast", "valuePath": "cpu"}
+
+
+def test_listen_with_filter_and_event():
+    s = bind.listen("battery", event="metrics", filter={"msg_type": "telemetry"})
+    assert s["event"] == "metrics"
+    assert s["filter"] == {"msg_type": "telemetry"}
+    assert s["valuePath"] == "battery"
+
+
+def test_action_broadcast_default():
+    assert bind.action("refresh") == {
+        "method": "meshsocket", "mode": "broadcast", "event": "refresh"}
+
+
+def test_action_request_with_payload():
+    a = bind.action("set_power", payload={"state": "{{value}}"}, mode="request")
+    assert a["mode"] == "request"
+    assert a["payload"] == {"state": "{{value}}"}
+
+
+def test_action_rejects_bad_mode():
+    with pytest.raises(ValueError):
+        bind.action("x", mode="nope")
+
+
+def test_connection():
+    c = bind.connection("ws://h:8765", channel="lab", token="t")
+    assert c["url"] == "ws://h:8765"
+    assert c["identity"] == {"name": "CAR-TER", "channel": "lab", "role": "controller"}
+    assert c["token"] == "t"

carterkit-0.2.0/tests/test_cli.py

@@ -0,0 +1,53 @@
+"""Tests for the carterkit CLI."""
+
+import json
+
+import carterkit
+from carterkit import cli
+
+
+def test_catalog_json(capsys):
+    assert cli.main(["catalog", "--json"]) == 0
+    cat = json.loads(capsys.readouterr().out)
+    assert "gauge" in cat and "button" in cat
+
+
+def test_catalog_table(capsys):
+    assert cli.main(["catalog"]) == 0
+    assert "gauge" in capsys.readouterr().out
+
+
+def test_doc(capsys):
+    assert cli.main(["doc", "gauge"]) == 0
+    assert "# Gauge" in capsys.readouterr().out
+
+
+def test_doc_unknown(capsys):
+    assert cli.main(["doc", "frobnicator"]) == 1
+
+
+def test_examples_list(capsys):
+    assert cli.main(["examples", "button"]) == 0
+    assert "•" in capsys.readouterr().out
+
+
+def test_version(capsys):
+    assert cli.main(["version"]) == 0
+    assert capsys.readouterr().out.strip() == carterkit.__version__
+
+
+def test_validate_clean(tmp_path):
+    b = carterkit.LayoutBuffer.blank(columns=4, rows=4)
+    b.add_control(carterkit.build.gauge(id="cpu", min=0, max=100), default_span=[2, 2])
+    f = tmp_path / "layout.json"
+    f.write_text(json.dumps(b.layout))
+    assert cli.main(["validate", str(f)]) == 0
+
+
+def test_gen_emits_meshsocket_service(tmp_path, capsys):
+    b = carterkit.LayoutBuffer.blank(columns=4, rows=4)
+    b.add_control(carterkit.build.button(id="go"))
+    f = tmp_path / "layout.json"
+    f.write_text(json.dumps(b.layout))
+    assert cli.main(["gen", str(f)]) == 0
+    assert "from meshsocket import MeshSocket" in capsys.readouterr().out

carterkit-0.2.0/tests/test_controls.py

@@ -0,0 +1,54 @@
+"""Tests for controls.py — typed builders generated from the bundled catalog."""
+
+import pytest
+
+import carterkit
+from carterkit import build, control
+
+
+def test_build_gauge_returns_valid_control():
+    g = build.gauge(id="cpu", min=0, max=100, position=[0, 0], span=[2, 2])
+    assert g["type"] == "gauge" and g["id"] == "cpu"
+    assert g["position"] == [0, 0] and g["span"] == [2, 2]
+    assert g["min"] == 0 and g["max"] == 100
+
+
+def test_snake_case_alias_maps_to_camel_type():
+    assert build.color_picker(id="tint")["type"] == "colorPicker"
+    assert build.status_light(id="s")["type"] == "statusLight"
+
+
+def test_unknown_control_raises():
+    with pytest.raises(AttributeError):
+        build.frobnicator  # noqa: B018
+
+
+def test_bad_enum_value_raises():
+    with pytest.raises(ValueError):
+        build.gauge(id="g", gaugeStyle="triangular")  # gaugeStyle is half|full
+
+
+def test_good_enum_value_ok():
+    assert build.gauge(id="g", gaugeStyle="full")["gaugeStyle"] == "full"
+
+
+def test_control_factory_unknown_type():
+    with pytest.raises(ValueError):
+        control("nope", id="x")
+
+
+def test_builder_doc_comes_from_controldocs():
+    assert build.gauge.__doc__.startswith("# Gauge")
+
+
+def test_types_listing_nonempty():
+    types = build.types()
+    assert "gauge" in types and "button" in types and "colorPicker" in types
+
+
+def test_built_controls_validate_clean():
+    b = carterkit.LayoutBuffer.blank(columns=4, rows=4)
+    b.add_control(build.gauge(id="cpu", min=0, max=100), default_span=[2, 2])
+    b.add_control(build.button(id="go", label="Go"))
+    errs = [f for f in carterkit.validate_layout(b.layout) if f["severity"] == "error"]
+    assert errs == [], errs