wapyt 0.2.0.dev1__tar.gz → 0.3.0__tar.gz

{wapyt-0.2.0.dev1 → wapyt-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wapyt
-Version: 0.2.0.dev1
+Version: 0.3.0
 Summary: DHTMLX-free pyTincture widgetset: layouts, forms, tables, trees, chat, terminal, menus, Kanban and more, declared in Python and rendered in the browser.
 License: MIT
 Project-URL: homepage, https://github.com/WAwesome-AI/wa_pytincture_widgetset
@@ -38,6 +38,7 @@ Description-Content-Type: text/markdown
 - `Popup` and tooltips: An anchored popover for pickers, help and small forms; styled, keyboard-reachable tooltips that replace native `title` text across the widgets.
 - `ProgressBar` / `progress_html`: Determinate or indeterminate bars with active/done/error/paused states, as a live widget or static markup.
 - `Pagination`: First/previous/next/last, a page box or numbered buttons, a page-size selector and a "1–50 of 1,234" summary; copes with totals the server could not count.
+- `MediaPlayer`: Video and audio with a queue — the picture in place, an audio bar that can dock to the foot of the window, or a compact inline player for a chat message; HLS through bundled hls.js, WebVTT subtitles, items whose URL is resolved only when reached, exclusive groups, keyboard and OS media keys, buttons of the app's own in the bar (`MediaAction`, `on_action`: "add to playlist", "save"), and any media source: files from disk, a CDN, cookies, Bearer headers (`MediaItem(headers=…)`), expiring signed URLs (`refresh()`), live streams (`live=True`) and a Quality menu.
 
 ## Runtime Architecture
 - Layouts and widgets are declared in Python but render as DOM nodes through the JavaScript bundles under `wapyt/assets/`. Each helper (e.g., `Layout.add_chat`) forwards config dictionaries directly to the matching JS constructor.

{wapyt-0.2.0.dev1 → wapyt-0.3.0}/README.md

@@ -26,6 +26,7 @@
 - `Popup` and tooltips: An anchored popover for pickers, help and small forms; styled, keyboard-reachable tooltips that replace native `title` text across the widgets.
 - `ProgressBar` / `progress_html`: Determinate or indeterminate bars with active/done/error/paused states, as a live widget or static markup.
 - `Pagination`: First/previous/next/last, a page box or numbered buttons, a page-size selector and a "1–50 of 1,234" summary; copes with totals the server could not count.
+- `MediaPlayer`: Video and audio with a queue — the picture in place, an audio bar that can dock to the foot of the window, or a compact inline player for a chat message; HLS through bundled hls.js, WebVTT subtitles, items whose URL is resolved only when reached, exclusive groups, keyboard and OS media keys, buttons of the app's own in the bar (`MediaAction`, `on_action`: "add to playlist", "save"), and any media source: files from disk, a CDN, cookies, Bearer headers (`MediaItem(headers=…)`), expiring signed URLs (`refresh()`), live streams (`live=True`) and a Quality menu.
 
 ## Runtime Architecture
 - Layouts and widgets are declared in Python but render as DOM nodes through the JavaScript bundles under `wapyt/assets/`. Each helper (e.g., `Layout.add_chat`) forwards config dictionaries directly to the matching JS constructor.

{wapyt-0.2.0.dev1 → wapyt-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "wapyt"
-version = "0.2.0.dev1"
+version = "0.3.0"
 description = "DHTMLX-free pyTincture widgetset: layouts, forms, tables, trees, chat, terminal, menus, Kanban and more, declared in Python and rendered in the browser."
 readme = "README.md"
 license = { text = "MIT" }

wapyt-0.3.0/tests/test_config_none.py

@@ -0,0 +1,74 @@
+"""Every config follows one None convention: unset means "not sent"."""
+from __future__ import annotations
+
+import dataclasses
+import importlib
+import inspect
+import pkgutil
+
+import pytest
+
+import wapyt
+from wapyt._config import drop_none
+
+# Fields whose None means "none" (hide it), so JS must see null. Keep short.
+ALLOWED_NULLS = {
+    ("FormConfig", "cancelText"),
+    ("FormConfig", "submitText"),
+    ("SidebarConfig", "title"),
+}
+
+# Classes that cannot be built from defaults alone get minimal arguments.
+ARGS = {
+    "MenuItem": {"id": "m"},
+    "ScheduleItem": {"id": "s", "start": "2026-10-08T09:00"},
+}
+
+
+def _config_classes():
+    for info in pkgutil.walk_packages(wapyt.__path__, "wapyt."):
+        module = importlib.import_module(info.name)
+        for name, cls in inspect.getmembers(module, inspect.isclass):
+            if cls.__module__ == module.__name__ and dataclasses.is_dataclass(cls) and hasattr(cls, "to_dict"):
+                yield cls
+
+
+def _build(cls):
+    if cls.__name__ in ARGS:
+        return cls(**ARGS[cls.__name__])
+    required = {
+        f.name: "x"
+        for f in dataclasses.fields(cls)
+        if f.init and f.default is dataclasses.MISSING and f.default_factory is dataclasses.MISSING
+    }
+    return cls(**required)
+
+
+def _nulls(value, path=""):
+    if isinstance(value, dict):
+        for key, item in value.items():
+            if item is None:
+                yield path + key
+            else:
+                yield from _nulls(item, f"{path}{key}.")
+    elif isinstance(value, list):
+        for index, item in enumerate(value):
+            yield from _nulls(item, f"{path}[{index}].")
+
+
+CLASSES = sorted(set(_config_classes()), key=lambda c: (c.__module__, c.__name__))
+
+
+def test_found_the_configs():
+    assert len(CLASSES) > 40
+
+
+@pytest.mark.parametrize("cls", CLASSES, ids=lambda c: c.__name__)
+def test_defaults_send_no_nulls(cls):
+    payload = _build(cls).to_dict()
+    unexpected = [p for p in _nulls(payload) if (cls.__name__, p) not in ALLOWED_NULLS]
+    assert unexpected == []
+
+
+def test_drop_none_is_shallow():
+    assert drop_none({"a": None, "b": 0, "c": False, "d": {"e": None}}) == {"b": 0, "c": False, "d": {"e": None}}

wapyt-0.3.0/tests/test_mediaplayer.py

@@ -0,0 +1,127 @@
+"""CPython tests for the MediaPlayer config (no browser needed)."""
+from __future__ import annotations
+
+import pytest
+
+import wapyt
+from wapyt import MediaItem, MediaPlayerConfig, MediaTextTrack
+from wapyt.mediaplayer.mediaplayer import resolve_patch
+
+
+def test_exported_with_a_layout_helper():
+    from wapyt.layout.layout import Layout
+    assert {"MediaPlayer", "MediaPlayerConfig", "MediaItem", "MediaTextTrack"} <= set(wapyt.__all__)
+    assert hasattr(Layout, "add_mediaplayer")
+
+
+def test_defaults_are_minimal():
+    assert MediaPlayerConfig().to_dict() == {"mode": "auto"}
+    assert MediaItem("/a.mp4").to_dict() == {"src": "/a.mp4"}
+    assert MediaTextTrack("/a.vtt").to_dict() == {"src": "/a.vtt"}
+
+
+def test_an_item_without_src_is_allowed():
+    # Resolved when it becomes current (the "resolve" event).
+    assert MediaItem(title="Later", data={"id": 7}).to_dict() == {"title": "Later", "data": {"id": 7}}
+
+
+def test_options_are_camel_cased():
+    payload = MediaPlayerConfig(
+        items=[MediaItem("/a.m3u8", title="A", subtitle="S", album="Al", poster="/p.jpg", type="hls",
+                         kind="video", start=12.5, data={"id": 1},
+                         text_tracks=[MediaTextTrack("/a.vtt", "English", "en", kind="captions", default=True)])],
+        mode="audio", autoplay=True, controls=False, muted=True, volume=0.5, rate=1.5, repeat="all",
+        shuffle=True, dock="bottom", group="chat", keyboard=False, media_session=False, queue_line=False,
+        show_shuffle=False, show_repeat=False, time_update_interval=0, preload="none",
+        cross_origin="anonymous", hls_config={"maxBufferLength": 30}, height=64, empty_text="—",
+        aria_label="Music",
+    ).to_dict()
+    assert payload["items"] == [{"src": "/a.m3u8", "title": "A", "subtitle": "S", "album": "Al", "poster": "/p.jpg",
+                                 "type": "hls", "kind": "video", "start": 12.5, "data": {"id": 1},
+                                 "textTracks": [{"src": "/a.vtt", "label": "English", "language": "en",
+                                                 "kind": "captions", "default": True}]}]
+    for key, value in {"mode": "audio", "autoplay": True, "controls": False, "muted": True, "volume": 0.5,
+                       "rate": 1.5, "repeat": "all", "shuffle": True, "dock": "bottom", "group": "chat",
+                       "keyboard": False, "mediaSession": False, "queueLine": False, "showShuffle": False,
+                       "showRepeat": False, "timeUpdateInterval": 0, "preload": "none",
+                       "crossOrigin": "anonymous", "hlsConfig": {"maxBufferLength": 30}, "height": 64,
+                       "emptyText": "—", "ariaLabel": "Music"}.items():
+        assert payload[key] == value, key
+
+
+def test_dict_items_pass_through():
+    assert MediaPlayerConfig(items=[{"src": "/x.mp3"}]).to_dict()["items"] == [{"src": "/x.mp3"}]
+
+
+@pytest.mark.parametrize("bad", [dict(mode="theatre"), dict(repeat="twice"), dict(dock="top"), dict(preload="all"),
+                                 dict(cross_origin="yes"), dict(volume=1.5), dict(rate=8),
+                                 dict(time_update_interval=-1),
+                                 dict(items=[MediaItem("/a.mp4")], start_index=1)])
+def test_invalid_configs(bad):
+    with pytest.raises(ValueError):
+        MediaPlayerConfig(**bad).to_dict()
+
+
+@pytest.mark.parametrize("bad", [dict(kind="podcast"), dict(start=-1), dict(data={1, 2})])
+def test_invalid_items(bad):
+    with pytest.raises(ValueError):
+        MediaItem("/a.mp4", **bad).to_dict()
+
+
+def test_invalid_text_tracks():
+    with pytest.raises(ValueError):
+        MediaTextTrack("/a.vtt", kind="karaoke").to_dict()
+    with pytest.raises(ValueError):
+        MediaTextTrack("").to_dict()
+
+
+def test_resolve_patch_shape():
+    assert resolve_patch("/s.m3u8", type="hls") == {"src": "/s.m3u8", "type": "hls"}
+    assert resolve_patch(error="gone") == {"error": "gone"}
+    assert resolve_patch("/a", text_tracks=[MediaTextTrack("/a.vtt", "En")]) == {
+        "src": "/a", "textTracks": [{"src": "/a.vtt", "label": "En"}]}
+    with pytest.raises(ValueError):
+        resolve_patch("/a", kind="slideshow")
+
+
+def test_assets_are_in_the_manifest_in_order():
+    import json
+    from pathlib import Path
+    manifest = json.loads((Path(wapyt.__file__).parent / "pytincture-assets.json").read_text())
+    paths = [a["path"] for a in manifest["assets"]]
+    assert paths.index("wapyt/assets/vendor-hlsjs.light.min.js") < paths.index("wapyt/assets/mediaplayer.js")
+
+
+def test_actions_are_the_apps_own_buttons():
+    from wapyt import MediaAction
+    payload = MediaPlayerConfig(actions=[
+        MediaAction("playlist", "mdi-playlist-plus", "Add to playlist"),
+        MediaAction("like", "mdi-heart-outline", "Like", pressed=False, disabled=True),
+    ]).to_dict()
+    assert payload["actions"] == [
+        {"id": "playlist", "icon": "mdi-playlist-plus", "label": "Add to playlist"},
+        {"id": "like", "icon": "mdi-heart-outline", "label": "Like", "pressed": False, "disabled": True},
+    ]
+    assert MediaAction("x").to_dict() == {"id": "x", "icon": "mdi-dots-horizontal", "label": "x"}
+    with pytest.raises(ValueError):
+        MediaAction("").to_dict()
+    with pytest.raises(ValueError):
+        MediaPlayerConfig(actions=[MediaAction("a"), MediaAction("a")]).to_dict()
+    assert "actions" not in MediaPlayerConfig().to_dict()
+
+
+def test_headers_and_live_for_any_media_server():
+    item = MediaItem("/live/channel.m3u8", headers={"Authorization": "Bearer abc", "X-Api-Key": "k"}, live=True)
+    assert item.to_dict() == {"src": "/live/channel.m3u8", "headers": {"Authorization": "Bearer abc", "X-Api-Key": "k"}, "live": True}
+    for bad in ({"Bad Name": "x"}, {"X": "two\r\nlines"}, {"X": 3}):
+        with pytest.raises(ValueError):
+            MediaItem("/a.m3u8", headers=bad).to_dict()
+    assert resolve_patch("/s.m3u8", headers={"Authorization": "Bearer t"}, live=False) == {
+        "src": "/s.m3u8", "headers": {"Authorization": "Bearer t"}, "live": False}
+    with pytest.raises(ValueError):
+        resolve_patch("/s.m3u8", headers={"A": "b\nc"})
+
+
+def test_quality_menu_can_be_turned_off():
+    assert MediaPlayerConfig(show_quality=False).to_dict() == {"mode": "auto", "showQuality": False}
+    assert "showQuality" not in MediaPlayerConfig().to_dict()

{wapyt-0.2.0.dev1 → wapyt-0.3.0}/tests/test_new_widget_configs.py

@@ -56,6 +56,11 @@ def test_terminal_clipboard_is_on_by_default_and_can_be_turned_off():
     assert roundtrip(TerminalConfig(clipboard=False))["clipboard"] is False
 
 
+def test_terminal_osc52_is_on_by_default_and_can_be_turned_off():
+    assert roundtrip(TerminalConfig())["osc52"] is True
+    assert roundtrip(TerminalConfig(osc52=False))["osc52"] is False
+
+
 def test_terminal_extra_passes_through():
     payload = roundtrip(TerminalConfig(extra={"customFlag": 7}))
     assert payload["customFlag"] == 7

wapyt-0.3.0/tests/test_quiet_imports.py

@@ -0,0 +1,18 @@
+"""Importing a widget module must not write to stdout or log above DEBUG."""
+import importlib
+import logging
+import sys
+
+import pytest
+
+MODULES = ["wapyt.chat.chat", "wapyt.cardpanel.cardpanel"]
+
+
+@pytest.mark.parametrize("name", MODULES)
+def test_import_is_quiet(name, capsys, caplog):
+    sys.modules.pop(name, None)
+    with caplog.at_level(logging.INFO):
+        importlib.import_module(name)
+    out = capsys.readouterr()
+    assert out.out == "" and out.err == ""
+    assert not [r for r in caplog.records if r.name == name]

wapyt-0.3.0/tests/test_source_warnings.py

@@ -0,0 +1,18 @@
+"""Every wapyt module compiles without warnings (no invalid escapes and the like)."""
+from __future__ import annotations
+
+import pathlib
+import warnings
+
+import pytest
+
+ROOT = pathlib.Path(__file__).resolve().parents[1] / "wapyt"
+
+
+@pytest.mark.parametrize("path", sorted(ROOT.rglob("*.py")), ids=lambda p: str(p.relative_to(ROOT)))
+def test_compiles_without_warnings(path):
+    # An invalid escape such as "\;" in a normal string is a SyntaxWarning
+    # today (on every import, in every app) and an error in a future Python.
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")
+        compile(path.read_text(encoding="utf-8"), str(path), "exec")

wapyt-0.3.0/tests/test_theme_system.py

@@ -0,0 +1,64 @@
+"""
+wapyt.setTheme in layout.js: "system" follows prefers-color-scheme. Run the
+real script under Node with a fake document and matchMedia (skipped when
+node is missing).
+"""
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+from pathlib import Path
+
+import pytest
+
+SCRIPT = Path(__file__).resolve().parents[1] / "wapyt" / "assets" / "layout.js"
+
+HARNESS = """
+const attrs = {};
+globalThis.document = { documentElement: {
+  setAttribute: (k, v) => { attrs[k] = String(v); },
+  getAttribute: (k) => (k in attrs ? attrs[k] : null),
+} };
+const listeners = [];
+const query = { matches: process.argv[2] === "dark",
+  addEventListener: (type, fn) => listeners.push(fn) };
+globalThis.matchMedia = () => query;
+require("vm").runInThisContext(require("fs").readFileSync(process.argv[1], "utf8"));
+const log = [];
+const snap = (label) => log.push([label, attrs["data-wapyt-theme"], attrs["data-wapyt-theme-mode"],
+  globalThis.wapyt.getTheme()]);
+const osTo = (dark) => { query.matches = dark; listeners.forEach((fn) => fn({ matches: dark })); };
+for (const step of JSON.parse(process.argv[3])) {
+  if (step[0] === "set") globalThis.wapyt.setTheme(step[1]);
+  else osTo(step[1] === "dark");
+  snap(step.join(" "));
+}
+console.log(JSON.stringify(log));
+"""
+
+
+def run(os_scheme: str, steps):
+    node = shutil.which("node")
+    if not node:
+        pytest.skip("node is not installed")
+    out = subprocess.run([node, "-e", HARNESS, str(SCRIPT), os_scheme, json.dumps(steps)],
+                         capture_output=True, text=True, check=True)
+    return [(theme, mode, info) for _label, theme, mode, info in json.loads(out.stdout)]
+
+
+def test_system_resolves_and_follows_the_os():
+    result = run("dark", [["set", "system"], ["os", "light"], ["os", "dark"]])
+    assert [r[0] for r in result] == ["dark", "light", "dark"]
+    assert all(r[1] == "system" for r in result)
+    assert result[1][2] == {"mode": "system", "resolved": "light"}
+
+
+def test_explicit_theme_ignores_the_os():
+    result = run("light", [["set", "system"], ["set", "light"], ["os", "dark"]])
+    assert result[-1][:2] == ("light", "light")
+
+
+def test_back_to_system_picks_up_the_current_os_setting():
+    result = run("light", [["set", "dark"], ["os", "light"], ["set", "System"]])
+    assert result[-1][:2] == ("light", "system")

wapyt-0.3.0/tests/test_themeeditor.py

@@ -0,0 +1,120 @@
+"""ThemeEditor config, theme validation and the wrapper's calls."""
+from __future__ import annotations
+
+import json
+from types import SimpleNamespace
+
+import pytest
+
+import wapyt.themeeditor.themeeditor as te_module
+from wapyt import ThemeEditor, ThemeEditorConfig, ThemePalette
+from wapyt.themeeditor import check_theme
+from wapyt.themeeditor.themeeditor_config import normalize_hex
+
+
+def test_default_config():
+    assert ThemeEditorConfig().to_dict() == {
+        "previewMode": True, "apply": True, "showShape": True, "showFont": True,
+        "showExport": True, "title": "Theme",
+    }
+
+
+def test_title_none_is_sent_as_null():
+    assert ThemeEditorConfig(title=None).to_dict()["title"] is None
+
+
+def test_palettes_mix_built_ins_and_custom():
+    brand = ThemePalette("brand", "Brand", light={"accent": "#0A7"}, dark={"accent": "#0c9"})
+    payload = ThemeEditorConfig(palettes=["default", brand], value={"palette": "brand"}).to_dict()
+    assert payload["palettes"] == ["default", {"id": "brand", "label": "Brand",
+                                               "light": {"accent": "#00aa77"}, "dark": {"accent": "#00cc99"}}]
+    assert payload["value"]["palette"] == "brand"
+
+
+@pytest.mark.parametrize("palettes, message", [
+    (["nope"], "unknown palette"),
+    ([], "at least one"),
+    ([ThemePalette("ocean")], "built-in"),
+    ([ThemePalette("x", light={"shadow": "#000"})], "unknown theme token"),
+])
+def test_bad_palettes(palettes, message):
+    with pytest.raises(ValueError, match=message):
+        ThemeEditorConfig(palettes=palettes).to_dict()
+
+
+def test_bad_mode():
+    with pytest.raises(ValueError):
+        ThemeEditorConfig(mode="sepia").to_dict()
+
+
+def test_check_theme_normalises():
+    assert check_theme({"palette": "forest", "dark": {"text": "#FFF"}, "radius": 7.6}) == {
+        "palette": "forest", "light": {}, "dark": {"text": "#ffffff"}, "radius": 8, "font": "system"}
+    assert check_theme(None)["palette"] == "default"
+
+
+@pytest.mark.parametrize("theme, message", [
+    ({"palette": "mystery"}, "unknown palette"),
+    ({"light": {"accent": "blue"}}, "not a hex"),
+    ({"light": {"glow": "#000"}}, "unknown theme token"),
+    ({"radius": 40}, "radius"),
+    ({"radius": True}, "radius"),
+    ({"colours": {}}, "unknown theme keys"),
+])
+def test_check_theme_rejects(theme, message):
+    with pytest.raises(ValueError, match=message):
+        check_theme(theme)
+
+
+def test_custom_palette_ids_are_accepted_when_named():
+    assert check_theme({"palette": "brand"}, ["brand"])["palette"] == "brand"
+
+
+@pytest.mark.parametrize("raw, hex_", [("#ABC", "#aabbcc"), ("123456", "#123456"), (" #0f0f0f ", "#0f0f0f")])
+def test_normalize_hex(raw, hex_):
+    assert normalize_hex(raw) == hex_
+
+
+class FakeEditor:
+    def __init__(self):
+        self.calls = []
+
+    def __getattr__(self, name):
+        return lambda *args: self.calls.append((name, args)) or {"palette": "default"}
+
+
+@pytest.fixture
+def editor(monkeypatch):
+    monkeypatch.setattr(te_module, "_to_js", lambda value: json.loads(json.dumps(value)))
+    w = object.__new__(ThemeEditor)
+    w.config = ThemeEditorConfig(palettes=["default", ThemePalette("brand")])
+    w.editor = FakeEditor()
+    return w
+
+
+def test_set_theme_validates_then_calls_js(editor):
+    editor.set_theme({"palette": "brand", "light": {"accent": "#ABC"}})
+    name, (theme, opts) = editor.editor.calls[-1]
+    assert name == "setTheme" and theme["light"] == {"accent": "#aabbcc"} and opts == {"silent": False}
+    with pytest.raises(ValueError):
+        editor.set_theme({"palette": "unknown"})
+
+
+def test_set_mode_checks_its_argument(editor):
+    editor.set_mode("dark")
+    assert editor.editor.calls[-1] == ("setMode", ("dark",))
+    with pytest.raises(ValueError):
+        editor.set_mode("dusk")
+
+
+def test_apply_theme_registers_palettes(monkeypatch):
+    calls = []
+    ns = SimpleNamespace(registerPalette=lambda spec: calls.append(("register", spec)),
+                         apply=lambda theme: calls.append(("apply", theme)) or theme)
+    monkeypatch.setattr(te_module, "_theme_js", lambda: ns)
+    monkeypatch.setattr(te_module, "_to_js", lambda value: value)
+    result = te_module.apply_theme({"palette": "brand"}, palettes=[ThemePalette("brand", light={"accent": "#000"})])
+    assert calls[0][0] == "register" and calls[1][0] == "apply"
+    assert result["palette"] == "brand"
+    te_module.apply_theme(None)
+    assert calls[-1] == ("apply", None)

wapyt-0.3.0/tests/test_themeeditor_js.py

@@ -0,0 +1,112 @@
+"""
+The theme model in themeeditor.js, run under Node (skipped without node):
+it must agree with the Python lists and with wapyt.css, and every built-in
+palette must meet its own contrast targets.
+"""
+from __future__ import annotations
+
+import json
+import re
+import shutil
+import subprocess
+from pathlib import Path
+
+import pytest
+
+from wapyt.themeeditor import FONTS, PALETTES, THEME_TOKENS
+
+ASSETS = Path(__file__).resolve().parents[1] / "wapyt" / "assets"
+
+HARNESS = r"""
+globalThis.document = { documentElement: { style: { setProperty(){}, removeProperty(){} },
+  setAttribute(){}, removeAttribute(){}, getAttribute(){ return null; } } };
+require("vm").runInThisContext(require("fs").readFileSync(process.argv[1], "utf8"));
+const T = globalThis.wapyt.theme;
+const accents = ["#2563eb", "#0e7490", "#facc15", "#ff00ff", "#111111", "#eeeeee", "#16a34a", "#9333ea"];
+const derived = {};
+for (const a of accents) for (const m of ["light", "dark"]) {
+  const d = T.deriveAccent(a, m);
+  derived[a + "/" + m] = { ...d, ratio: T.contrast(a, d["on-accent"]) };
+}
+console.log(JSON.stringify({
+  tokens: T.TOKENS.map((t) => ({ key: t.key, light: t.light, dark: t.dark, on: t.on || null, min: t.min || null })),
+  fonts: T.FONTS.map((f) => f.id),
+  palettes: T.palettes().map((p) => ({ id: p.id, ...T.resolve({ palette: p.id }) })),
+  defaults: T.DEFAULT,
+  normalized: T.normalize({ palette: "nope", light: { accent: "#ABC", bogus: "#000", text: "red" }, radius: 99 }),
+  ratioWhiteBlack: T.contrast("#ffffff", "#000000"),
+  derived,
+}));
+"""
+
+
+@pytest.fixture(scope="module")
+def model():
+    node = shutil.which("node")
+    if not node:
+        pytest.skip("node is not installed")
+    out = subprocess.run([node, "-e", HARNESS, str(ASSETS / "themeeditor.js")],
+                         capture_output=True, text=True, check=True)
+    return json.loads(out.stdout)
+
+
+def _lum(hex_):
+    def ch(v):
+        c = int(v, 16) / 255
+        return c / 12.92 if c <= 0.03928 else ((c + 0.055) / 1.055) ** 2.4
+    r, g, b = (ch(hex_[i:i + 2]) for i in (1, 3, 5))
+    return 0.2126 * r + 0.7152 * g + 0.0722 * b
+
+
+def ratio(a, b):
+    hi, lo = sorted((_lum(a), _lum(b)), reverse=True)
+    return (hi + 0.05) / (lo + 0.05)
+
+
+def test_lists_match_python(model):
+    assert [t["key"] for t in model["tokens"]] == THEME_TOKENS
+    assert [p["id"] for p in model["palettes"]] == PALETTES
+    assert model["fonts"] == FONTS
+
+
+def test_defaults_match_the_stylesheet(model):
+    css = (ASSETS / "wapyt.css").read_text()
+    root = css[css.index(":root {"):css.index("}", css.index(":root {"))]
+    declared = dict(re.findall(r"(--wapyt-[a-z-]+):\s*(#[0-9a-fA-F]{6})", root))
+    for tok in model["tokens"]:
+        for mode in ("light", "dark"):
+            assert declared[tok[mode]].lower() == model["defaults"][mode][tok["key"]], (tok["key"], mode)
+    assert "--wapyt-radius: 6px" in root
+
+
+def test_contrast_maths(model):
+    assert round(model["ratioWhiteBlack"], 2) == 21.0
+
+
+@pytest.mark.parametrize("mode", ["light", "dark"])
+def test_built_in_palettes_meet_their_targets(model, mode):
+    failures = []
+    for p in model["palettes"]:
+        v = p[mode]
+        for tok in model["tokens"]:
+            if not tok["on"] or tok["on"] == "tint":
+                continue
+            r = ratio(v[tok["key"]], v[tok["on"]])
+            if r < tok["min"]:
+                failures.append(f"{p['id']}/{mode}: {tok['key']} on {tok['on']} = {r:.2f} < {tok['min']}")
+        r = ratio(v["text"], v["surface"])
+        if r < 4.5:
+            failures.append(f"{p['id']}/{mode}: text on surface = {r:.2f}")
+    assert failures == []
+
+
+def test_normalize_drops_bad_values(model):
+    n = model["normalized"]
+    assert n["palette"] == "default"
+    assert n["light"] == {"accent": "#aabbcc"}
+    assert n["radius"] == 24
+
+
+def test_derived_accent_text_is_readable(model):
+    assert all(d["ratio"] >= 4.5 for d in model["derived"].values()), {
+        k: round(d["ratio"], 2) for k, d in model["derived"].items() if d["ratio"] < 4.5}