simple-module-cli 0.0.28__tar.gz → 0.0.29__tar.gz

{simple_module_cli-0.0.28 → simple_module_cli-0.0.29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simple_module_cli
-Version: 0.0.28
+Version: 0.0.29
 Summary: Standalone scaffolder for the SimpleModule framework — `smpy new`, `smpy create-module`, plugin host.
 Project-URL: Homepage, https://github.com/antosubash/simple_module_python
 Project-URL: Repository, https://github.com/antosubash/simple_module_python

{simple_module_cli-0.0.28 → simple_module_cli-0.0.29}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simple_module_cli"
-version = "0.0.28"
+version = "0.0.29"
 description = "Standalone scaffolder for the SimpleModule framework — `smpy new`, `smpy create-module`, plugin host."
 readme = "README.md"
 license = "MIT"

{simple_module_cli-0.0.28 → simple_module_cli-0.0.29}/simple_module_cli/templates/host/README.md.tpl

@@ -14,7 +14,7 @@ cp .env.example .env
 # First time only — initialize the migration history for the modules you
 # picked. Inspect the generated file, then apply it.
 alembic revision --autogenerate -m "initial schema"
-alembic upgrade head
+alembic upgrade heads
 
 # Run the API
 python main.py
@@ -39,7 +39,7 @@ uv add simple_module_my_module
 
 # 2) generate & apply the migration (new tables + any schema changes)
 alembic revision --autogenerate -m "add my-module"
-alembic upgrade head
+alembic upgrade heads
 
 # 3) restart the host — the module's routes, menu items, permissions,
 #    feature flags, events, and health checks register automatically

{simple_module_cli-0.0.28 → simple_module_cli-0.0.29}/simple_module_cli/templates/host/client_app/vite.config.ts

@@ -69,20 +69,35 @@ if (fs.existsSync(manifestPath)) {
   }
 }
 
-// Per-module aliases, so generated CSS can say
-//   @import "#module/gis/styles.css"
-// instead of a ../../../.venv/lib/python3.12/site-packages/gis/styles.css
-// path that breaks the moment the interpreter version changes.
+// Three things come out of modules.assets.json.
+//
+// 1. `server.fs.allow` entries. The dev server must be allowed to read each
+//    module's package dir. Read from modules.assets.json rather than
+//    modules.manifest.json because the manifest is keyed off `pages/`, so a
+//    module shipping only CSS never appears in it.
+//
+// 2. A convenience `#module/<pkg>` alias. This is NOT required by
+//    `modules.generated.css` — that file imports module stylesheets by
+//    absolute path, so it resolves with no alias configured at all. Emitting
+//    an alias there made a generated file depend on this hand-owned config,
+//    and since `vite.config.ts` is scaffolded once and then owned by the app,
+//    a Python-only version bump broke every host scaffolded earlier
+//    (GH issue #253). The alias stays because it costs nothing.
+//
+// 3. An `<npm_name>` alias per module, so one module can import another's
+//    TS/TSX by package name. Aimed at the module's *Python package* dir —
+//    a wheel ships `site-packages/foo/**` and nothing above it, so the
+//    source-tree module root is not a target both layouts have. Needed in
+//    both: a wheel module is never in node_modules, and npm symlinks a
+//    workspace member onto the module root, one level too high.
+//    See docs/module-authoring.md § Importing another module's TS/TSX.
 //
 // `@tailwindcss/vite` builds its CSS import resolver with
 // `createResolver({ ...config.resolve, ... })`, so `resolve.alias` governs
 // CSS `@import` as well as JS — verified against @tailwindcss/vite 4.2.4.
-//
-// Read from modules.assets.json rather than modules.manifest.json: the
-// manifest is keyed off `pages/`, so a module shipping only CSS never
-// appears in it.
-type ModuleAsset = { package_name: string; package: string };
+type ModuleAsset = { package_name: string; package: string; npm_name?: string | null };
 const moduleAliases: { find: string; replacement: string }[] = [];
+const moduleNpmNames = new Set<string>();
 const assetsPath = path.resolve(__dirname, 'modules.assets.json');
 let moduleAssets: Record<string, ModuleAsset> = {};
 try {
@@ -92,6 +107,10 @@ try {
 }
 for (const entry of Object.values(moduleAssets)) {
   moduleAliases.push({ find: `#module/${entry.package_name}`, replacement: entry.package });
+  if (entry.npm_name) {
+    moduleAliases.push({ find: entry.npm_name, replacement: entry.package });
+    moduleNpmNames.add(entry.npm_name);
+  }
   if (!moduleFsAllow.includes(entry.package)) moduleFsAllow.push(entry.package);
 }
 // Keep the alias list in a stable, longest-first order. Vite matches a string
@@ -169,6 +188,10 @@ function collectOptimizeIncludes(): string[] {
     for (const block of [pkg.dependencies, pkg.peerDependencies]) {
       for (const name of Object.keys(block ?? {})) {
         if (name.startsWith('@types/')) continue;
+        // A sibling module declared as a dep/peer dep is not a node_modules
+        // package — it is aliased to a source directory above. Pre-bundling
+        // it would point the optimizer at raw .tsx with no entry point.
+        if (moduleNpmNames.has(name)) continue;
         const nested = findPackageJSON(name);
         if (!nested) continue;
         const nestedPkg = readPackageJSON(nested);
@@ -231,8 +254,8 @@ export default defineConfig({
   plugins: [moduleBareImportResolver(), react(), tailwindcss()],
   root: __dirname,
   resolve: {
-    // `#module/<pkg>` -> that module's package directory. Consumed by the
-    // @import lines in modules.generated.css.
+    // `#module/<pkg>` -> that module's package directory. Optional sugar for
+    // hand-written imports; modules.generated.css does not rely on it.
     alias: moduleAliases,
     dedupe: [...REACT_CORE_DEPS, '@simple-module-py/ui', '@simple-module-py/i18n'],
   },

simple_module_cli-0.0.29/tests/conftest.py

@@ -0,0 +1,45 @@
+"""Fixtures shared by the module-asset tests in this directory.
+
+These test files have no ``__init__.py`` (test basenames are globally unique
+instead), so a plain helper import across files is not available — a fixture is
+how the factory below gets shared.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import pytest
+
+
+@pytest.fixture
+def make_importable_module(tmp_path: Path):
+    """Return a factory creating a real importable package bound to a ModuleBase.
+
+    ``get_module_package_name`` derives the package from the class's
+    ``__module__``, and ``compute_module_assets`` then resolves that package via
+    ``importlib.resources.files``. So the package has to genuinely exist on
+    ``sys.path`` — a mock won't exercise the code path we care about.
+
+    Returns ``(module_instance, package_dir)``.
+    """
+    from simple_module_core import ModuleBase, ModuleMeta
+
+    def _make(pkg_name: str, klass_name: str, *, root: Path | None = None):
+        base = root or tmp_path
+        pkg = base / pkg_name
+        pkg.mkdir(parents=True, exist_ok=True)
+        (pkg / "__init__.py").write_text("", encoding="utf-8")
+        if str(base) not in sys.path:
+            sys.path.insert(0, str(base))
+        sys.modules.pop(pkg_name, None)
+
+        klass = type(
+            klass_name,
+            (ModuleBase,),
+            {"meta": ModuleMeta(name=klass_name), "__module__": f"{pkg_name}.module"},
+        )
+        return klass(), pkg
+
+    return _make

{simple_module_cli-0.0.28 → simple_module_cli-0.0.29}/tests/test_module_css_assets.py

@@ -2,41 +2,15 @@
 
 from __future__ import annotations
 
-import sys
 from pathlib import Path
 
 
-def _make_importable_module(tmp_path: Path, pkg_name: str, klass_name: str):
-    """Create a real importable package on disk and return a ModuleBase bound to it.
-
-    ``get_module_package_name`` derives the package from the class's
-    ``__module__``, and ``compute_module_assets`` then resolves that package
-    via ``importlib.resources.files``. So the package has to genuinely exist
-    on ``sys.path`` — a mock won't exercise the code path we care about.
-    """
-    from simple_module_core import ModuleBase, ModuleMeta
-
-    pkg = tmp_path / pkg_name
-    pkg.mkdir(parents=True, exist_ok=True)
-    (pkg / "__init__.py").write_text("", encoding="utf-8")
-    if str(tmp_path) not in sys.path:
-        sys.path.insert(0, str(tmp_path))
-    sys.modules.pop(pkg_name, None)
-
-    klass = type(
-        klass_name,
-        (ModuleBase,),
-        {"meta": ModuleMeta(name=klass_name), "__module__": f"{pkg_name}.module"},
-    )
-    return klass(), pkg
-
-
 class TestComputeModuleAssets:
-    async def test_detects_theme_and_styles(self, tmp_path):
+    async def test_detects_theme_and_styles(self, make_importable_module):
         """A module shipping theme.css/styles.css has both detected."""
         from simple_module_hosting.assets import compute_module_assets
 
-        mod, pkg = _make_importable_module(tmp_path, "styled_mod", "Styled")
+        mod, pkg = make_importable_module("styled_mod", "Styled")
         (pkg / "pages").mkdir()
         (pkg / "theme.css").write_text("@theme { --color-x: red; }\n", encoding="utf-8")
         (pkg / "styles.css").write_text(".x { color: red; }\n", encoding="utf-8")
@@ -50,11 +24,11 @@ class TestComputeModuleAssets:
         assert entry.styles_css is not None and entry.styles_css.name == "styles.css"
         assert entry.pages_dir is not None
 
-    async def test_css_only_module_is_included(self, tmp_path):
+    async def test_css_only_module_is_included(self, make_importable_module):
         """A module with CSS but no pages/ still appears — the manifest.json gap."""
         from simple_module_hosting.assets import compute_module_assets
 
-        mod, pkg = _make_importable_module(tmp_path, "cssonly_mod", "CssOnly")
+        mod, pkg = make_importable_module("cssonly_mod", "CssOnly")
         (pkg / "styles.css").write_text(".y { color: blue; }\n", encoding="utf-8")
 
         result = compute_module_assets([mod])
@@ -64,11 +38,11 @@ class TestComputeModuleAssets:
         assert result[0].theme_css is None
         assert result[0].styles_css is not None
 
-    async def test_module_with_no_assets_is_omitted(self, tmp_path):
+    async def test_module_with_no_assets_is_omitted(self, make_importable_module):
         """A module contributing nothing frontend-ish is skipped, not an error."""
         from simple_module_hosting.assets import compute_module_assets
 
-        mod, _pkg = _make_importable_module(tmp_path, "headless_mod", "Headless")
+        mod, _pkg = make_importable_module("headless_mod", "Headless")
 
         assert compute_module_assets([mod]) == []
 
@@ -105,15 +79,13 @@ class TestCssEmission:
         """theme.css imports unlayered; styles.css imports into layer(components)."""
         from simple_module_hosting.assets import render_modules_css
 
-        entry = _assets(
-            tmp_path,
-            theme_css=tmp_path / "gis" / "theme.css",
-            styles_css=tmp_path / "gis" / "styles.css",
-        )
+        theme = tmp_path / "gis" / "theme.css"
+        styles = tmp_path / "gis" / "styles.css"
+        entry = _assets(tmp_path, theme_css=theme, styles_css=styles)
         css = render_modules_css([entry], in_repo=lambda _p: False)
 
-        assert '@import "#module/gis/theme.css";' in css
-        assert '@import "#module/gis/styles.css" layer(components);' in css
+        assert f'@import "{theme.as_posix()}";' in css
+        assert f'@import "{styles.as_posix()}" layer(components);' in css
         # Tokens must be declared before the rules that consume them.
         assert css.index("theme.css") < css.index("styles.css")
 
@@ -121,17 +93,18 @@ class TestCssEmission:
         """@source is wheel-only; @import is emitted for every module."""
         from simple_module_hosting.assets import render_modules_css
 
+        styles = tmp_path / "local" / "styles.css"
         entry = _assets(
             tmp_path,
             name="Local",
             package_name="local",
             pages_dir=tmp_path / "local" / "pages",
-            styles_css=tmp_path / "local" / "styles.css",
+            styles_css=styles,
         )
         css = render_modules_css([entry], in_repo=lambda _p: True)
 
         assert "@source" not in css, "in-repo pages are covered by the static glob"
-        assert '@import "#module/local/styles.css" layer(components);' in css
+        assert f'@import "{styles.as_posix()}" layer(components);' in css
 
     async def test_source_emitted_for_wheel_modules(self, tmp_path):
         """A wheel-installed module gets an absolute @source glob."""
@@ -154,9 +127,11 @@ class TestCssEmission:
     async def test_output_is_formatter_clean(self, tmp_path):
         """No doubled blank lines, exactly one trailing newline.
 
-        `biome ci .` lints the whole tree, and `modules.generated.css` is
-        untracked but not exempt — so a stray blank line here fails `make lint`
-        for anyone who has run `gen-pages`.
+        `modules.generated.css` is excluded from `biome ci .` (it is generated,
+        and its absolute paths make its formatting machine-dependent — whether
+        a line exceeds biome's 100-char `lineWidth` depends on where the repo
+        happens to live). Nothing enforces tidiness here but this test, and a
+        file humans read when debugging a missing style should stay readable.
         """
         from simple_module_hosting.assets import render_modules_css
 
@@ -171,18 +146,34 @@ class TestCssEmission:
         empty = render_modules_css([], in_repo=lambda _p: False)
         assert "\n\n\n" not in empty and empty.endswith("\n")
 
-    async def test_no_relative_paths_anywhere(self, tmp_path):
-        """The whole point of aliases: generated @import lines never use ../.."""
+    async def test_generated_css_is_self_contained(self, tmp_path):
+        """Every emitted path resolves without any host `vite.config.ts` help.
+
+        Regression guard for GH issue #253. `modules.generated.css` is
+        regenerated from the installed Python packages, but `vite.config.ts` is
+        scaffold output owned by the app — so anything here that needs a host
+        alias to resolve breaks every host scaffolded before that alias
+        existed, on a Python-only version bump.
+
+        Absolute, on-disk paths are the invariant that makes the two files
+        independently versionable.
+        """
         from simple_module_core import discover_modules
         from simple_module_hosting.manifest import write_module_pages_manifest
 
         written = write_module_pages_manifest(discover_modules(), tmp_path)
         css = written["css"].read_text(encoding="utf-8")
 
-        for line in css.splitlines():
-            if line.startswith("@import"):
-                assert "../" not in line, f"@import must not use a relative path: {line}"
-                assert '"#module/' in line, f"@import must use the alias prefix: {line}"
+        imports = [ln for ln in css.splitlines() if ln.startswith("@import")]
+        assert imports, "expected at least one module stylesheet import"
+        for line in imports:
+            target = Path(line.split('"')[1])
+            assert target.is_absolute(), f"@import must be absolute: {line}"
+            assert "../" not in line, f"@import must not use a relative path: {line}"
+            assert not line.split('"')[1].startswith("#"), (
+                f"@import must not use an alias the host has to define: {line}"
+            )
+            assert target.is_file(), f"@import points at a file that does not exist: {line}"
 
 
 class TestAssetsManifest:
@@ -203,7 +194,15 @@ class TestAssetsManifest:
         entry = data["Dashboard"]
         assert entry["package_name"] == "dashboard"
         assert entry["package"].endswith("dashboard")
-        assert set(entry) == {"package_name", "package", "pages", "theme", "styles"}
+        assert entry["npm_name"] == "@simple-module-py/dashboard"
+        assert set(entry) == {
+            "package_name",
+            "package",
+            "pages",
+            "theme",
+            "styles",
+            "npm_name",
+        }
 
     async def test_manifest_json_shape_unchanged(self, tmp_path):
         """modules.manifest.json stays {name: pages_dir} for downstream vite configs.

simple_module_cli-0.0.29/tests/test_module_css_build.py

@@ -0,0 +1,144 @@
+"""Proves module-shipped CSS survives a real Tailwind build.
+
+Every unit test around `render_modules_css` can stay green while Tailwind
+emits nothing at all — the generated `@import` only pays off if Tailwind
+resolves the path and keeps the rule. This is the one assertion that exercises
+that whole chain, so it drives a genuine build rather than inspecting the
+generated text.
+
+Skipped where a build is impossible: CI's `python-tests` job installs Python
+deps only (`make install-py`), so `node_modules` is absent there. The JS jobs
+and local runs do have it.
+"""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+from pathlib import Path
+
+import pytest
+
+REPO_ROOT = Path(__file__).resolve().parents[3]
+
+pytestmark = [
+    pytest.mark.skipif(
+        not (REPO_ROOT / "node_modules").is_dir(),
+        reason="node_modules absent — run `npm install` to exercise the real build",
+    ),
+    pytest.mark.skipif(shutil.which("npm") is None, reason="npm not on PATH"),
+]
+
+
+class TestModuleCssReachesBundle:
+    def test_module_class_is_emitted_by_vite_build(self):
+        """A class defined only in a module's styles.css appears in the built CSS.
+
+        `.dashboard-stat-grid` is declared in modules/dashboard/dashboard/styles.css
+        and referenced by no TSX anywhere, so it can only reach the bundle via the
+        generated `@import` of that stylesheet.
+        """
+        subprocess.run(
+            [
+                "uv",
+                "run",
+                "--project",
+                "host",
+                "smpy",
+                "host",
+                "gen-pages",
+                "--host-dir=host/client_app",
+            ],
+            cwd=REPO_ROOT,
+            check=True,
+            capture_output=True,
+        )
+
+        generated = (REPO_ROOT / "host/client_app/modules.generated.css").read_text(
+            encoding="utf-8"
+        )
+        dashboard_css = REPO_ROOT / "modules/dashboard/dashboard/styles.css"
+        assert f'@import "{dashboard_css.as_posix()}" layer(components);' in generated, (
+            f"gen-pages did not emit the dashboard stylesheet import:\n{generated}"
+        )
+
+        subprocess.run(["npm", "run", "build"], cwd=REPO_ROOT, check=True, capture_output=True)
+
+        built = list((REPO_ROOT / "host/static/dist/assets").glob("*.css"))
+        assert built, "no CSS emitted by the build"
+        combined = "\n".join(p.read_text(encoding="utf-8") for p in built)
+        assert "dashboard-stat-grid" in combined, (
+            "module-shipped CSS did not reach the bundle — the generated "
+            "@import most likely failed to resolve"
+        )
+
+
+# Written into a real module's pages/ so the host build treats it exactly like
+# any other module page. Removed again in the fixture's teardown.
+PROBE_MODULE_PAGES = REPO_ROOT / "modules/audit_log/audit_log/pages"
+PROBE_PAGE = PROBE_MODULE_PAGES / "CrossModuleImportProbe.tsx"
+PROBE_SOURCE = """\
+// Generated by test_module_css_build.py — safe to delete.
+import { DemoPlaceholders } from '@simple-module-py/dashboard/pages/components/DemoPlaceholders';
+
+export default function CrossModuleImportProbe() {
+  return <DemoPlaceholders totalUsers={0} />;
+}
+"""
+
+
+@pytest.fixture
+def cross_module_probe_page():
+    """Add a page importing a sibling module by npm package name, then remove it."""
+    PROBE_PAGE.write_text(PROBE_SOURCE, encoding="utf-8")
+    try:
+        yield PROBE_PAGE
+    finally:
+        PROBE_PAGE.unlink(missing_ok=True)
+
+
+class TestCrossModuleImportResolves:
+    def test_module_can_import_a_sibling_by_npm_package_name(self, cross_module_probe_page):
+        """`@simple-module-py/<slug>/…` resolves to the sibling's package dir.
+
+        Nothing in Node's own resolution makes this work. A wheel-installed
+        module is not an npm workspace member at all, so it never lands in
+        node_modules; a workspace member *is* symlinked, but onto the
+        source-tree module root — one level above the Python package — so the
+        subpath lands somewhere that does not exist. Both cases are covered by
+        the `npm_name` aliases the host builds from modules.assets.json.
+
+        This can only be caught by a real build: every unit test around
+        `npm_name` stays green while the alias itself is missing or misaimed.
+        """
+        subprocess.run(
+            [
+                "uv",
+                "run",
+                "--project",
+                "host",
+                "smpy",
+                "host",
+                "gen-pages",
+                "--host-dir=host/client_app",
+            ],
+            cwd=REPO_ROOT,
+            check=True,
+            capture_output=True,
+        )
+
+        result = subprocess.run(
+            ["npm", "run", "build"], cwd=REPO_ROOT, capture_output=True, text=True
+        )
+        assert result.returncode == 0, (
+            "build failed — a module could not import a sibling by npm package "
+            f"name:\n{result.stderr[-2000:]}"
+        )
+
+        chunks = list((REPO_ROOT / "host/static/dist/assets").glob("CrossModuleImportProbe*.js"))
+        assert chunks, "probe page produced no chunk"
+        # Resolution really happened if the sibling's component was pulled in
+        # rather than the import being dropped or stubbed out.
+        assert any("DemoPlaceholders" in c.read_text(encoding="utf-8") for c in chunks), (
+            "probe chunk does not reference the sibling module's component"
+        )

simple_module_cli-0.0.29/tests/test_module_npm_aliases.py

@@ -0,0 +1,128 @@
+"""Tests for a module's npm identity — the `npm_name` in `modules.assets.json`.
+
+That field is what lets one module import another's TS/TSX by package name.
+The host aliases it onto the module's *Python package directory*, and the
+tests here pin both halves: that the name is discovered in either install
+layout, and that it is aimed at the one directory both layouts share.
+
+The real end-to-end proof lives in `test_module_css_build.py` — a bundler that
+never resolves the alias would leave every assertion here green.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+
+class TestNpmNameDiscovery:
+    async def test_read_from_wheel_layout(self, make_importable_module):
+        """A wheel embeds package.json *inside* the Python package.
+
+        Hatch force-includes the module-root `package.json` as
+        `<pkg>/package.json`, so that is where an installed module carries its
+        npm identity.
+        """
+        from simple_module_hosting.assets import compute_module_assets
+
+        mod, pkg = make_importable_module("wheelish_mod", "Wheelish")
+        (pkg / "pages").mkdir()
+        (pkg / "package.json").write_text(
+            json.dumps({"name": "@simple-module-py/wheelish"}), encoding="utf-8"
+        )
+
+        assert compute_module_assets([mod])[0].npm_name == "@simple-module-py/wheelish"
+
+    async def test_read_from_workspace_layout(self, make_importable_module):
+        """An editable install leaves package.json at the source-tree module root."""
+        from simple_module_hosting.assets import compute_module_assets
+
+        mod, pkg = make_importable_module("srcish_mod", "Srcish")
+        (pkg / "pages").mkdir()
+        (pkg.parent / "pyproject.toml").write_text("[project]\n", encoding="utf-8")
+        (pkg.parent / "package.json").write_text(
+            json.dumps({"name": "@simple-module-py/srcish"}), encoding="utf-8"
+        )
+
+        assert compute_module_assets([mod])[0].npm_name == "@simple-module-py/srcish"
+
+    async def test_parent_package_json_ignored_without_pyproject(self, make_importable_module):
+        """No `pyproject.toml` beside it means that directory is not a module root.
+
+        Without this guard a wheel-installed module would read whatever
+        `package.json` happened to sit in `site-packages/` and alias itself
+        onto a stranger's name.
+        """
+        from simple_module_hosting.assets import compute_module_assets
+
+        mod, pkg = make_importable_module("stray_mod", "Stray")
+        (pkg / "pages").mkdir()
+        (pkg.parent / "package.json").write_text(
+            json.dumps({"name": "totally-unrelated"}), encoding="utf-8"
+        )
+
+        assert compute_module_assets([mod])[0].npm_name is None
+
+    async def test_module_without_package_json(self, make_importable_module):
+        """A Python-only module contributes no npm identity — and must not crash."""
+        from simple_module_hosting.assets import compute_module_assets
+
+        mod, pkg = make_importable_module("nojs_mod", "NoJs")
+        (pkg / "styles.css").write_text(".z { color: red; }\n", encoding="utf-8")
+
+        assert compute_module_assets([mod])[0].npm_name is None
+
+    async def test_malformed_package_json_is_ignored(self, make_importable_module):
+        """A broken package.json degrades to "no npm name", never to a boot failure."""
+        from simple_module_hosting.assets import compute_module_assets
+
+        mod, pkg = make_importable_module("broken_mod", "Broken")
+        (pkg / "pages").mkdir()
+        (pkg / "package.json").write_text("{not json", encoding="utf-8")
+
+        assert compute_module_assets([mod])[0].npm_name is None
+
+
+class TestNpmAliasContract:
+    async def test_alias_target_is_the_python_package_dir(self, tmp_path):
+        """`npm_name` must alias onto `package`, not the source-tree module root.
+
+        This is the invariant that makes a cross-module import mean the same
+        thing in both install layouts. A wheel ships `site-packages/<pkg>/**`
+        and nothing above it — the module root does not survive installation —
+        so the Python package directory is the only anchor both layouts share.
+
+        Concretely: `@simple-module-py/dashboard/pages/Home` has to land on
+        `<package>/pages/Home`, which exists in a wheel and in a checkout.
+        """
+        from simple_module_core import discover_modules
+        from simple_module_hosting.manifest import write_module_pages_manifest
+
+        write_module_pages_manifest(discover_modules(), tmp_path)
+        data = json.loads((tmp_path / "modules.assets.json").read_text(encoding="utf-8"))
+
+        aliased = {k: v for k, v in data.items() if v["npm_name"]}
+        assert aliased, "expected at least one module shipping a package.json"
+        for name, entry in aliased.items():
+            package = Path(entry["package"])
+            assert package.is_dir(), f"{name}: alias target is not a directory"
+            assert package.name == entry["package_name"], (
+                f"{name}: npm name must alias onto the Python package dir "
+                f"({entry['package_name']}), not {package.name}"
+            )
+            if entry["pages"]:
+                assert Path(entry["pages"]).parent == package, (
+                    f"{name}: pages/ must sit directly under the alias target, "
+                    "or subpath imports resolve differently per install layout"
+                )
+
+    async def test_npm_names_are_unique(self, tmp_path):
+        """Two modules claiming one npm name would make the alias order-dependent."""
+        from simple_module_core import discover_modules
+        from simple_module_hosting.manifest import write_module_pages_manifest
+
+        write_module_pages_manifest(discover_modules(), tmp_path)
+        data = json.loads((tmp_path / "modules.assets.json").read_text(encoding="utf-8"))
+
+        names = [v["npm_name"] for v in data.values() if v["npm_name"]]
+        assert len(names) == len(set(names)), f"duplicate npm package names: {names}"

simple_module_cli-0.0.28/tests/test_module_css_build.py

@@ -1,72 +0,0 @@
-"""Proves module-shipped CSS survives a real Tailwind build.
-
-Every unit test around `render_modules_css` can stay green while Tailwind
-emits nothing at all — the generated `@import` only pays off if Vite resolves
-the `#module/<pkg>` alias and Tailwind keeps the rule. This is the one
-assertion that exercises that whole chain, so it drives a genuine build
-rather than inspecting the generated text.
-
-Skipped where a build is impossible: CI's `python-tests` job installs Python
-deps only (`make install-py`), so `node_modules` is absent there. The JS jobs
-and local runs do have it.
-"""
-
-from __future__ import annotations
-
-import shutil
-import subprocess
-from pathlib import Path
-
-import pytest
-
-REPO_ROOT = Path(__file__).resolve().parents[3]
-
-pytestmark = [
-    pytest.mark.skipif(
-        not (REPO_ROOT / "node_modules").is_dir(),
-        reason="node_modules absent — run `npm install` to exercise the real build",
-    ),
-    pytest.mark.skipif(shutil.which("npm") is None, reason="npm not on PATH"),
-]
-
-
-class TestModuleCssReachesBundle:
-    def test_module_class_is_emitted_by_vite_build(self):
-        """A class defined only in a module's styles.css appears in the built CSS.
-
-        `.dashboard-stat-grid` is declared in modules/dashboard/dashboard/styles.css
-        and referenced by no TSX anywhere, so it can only reach the bundle via the
-        generated `@import "#module/dashboard/styles.css"`.
-        """
-        subprocess.run(
-            [
-                "uv",
-                "run",
-                "--project",
-                "host",
-                "smpy",
-                "host",
-                "gen-pages",
-                "--host-dir=host/client_app",
-            ],
-            cwd=REPO_ROOT,
-            check=True,
-            capture_output=True,
-        )
-
-        generated = (REPO_ROOT / "host/client_app/modules.generated.css").read_text(
-            encoding="utf-8"
-        )
-        assert '@import "#module/dashboard/styles.css" layer(components);' in generated, (
-            f"gen-pages did not emit the dashboard stylesheet import:\n{generated}"
-        )
-
-        subprocess.run(["npm", "run", "build"], cwd=REPO_ROOT, check=True, capture_output=True)
-
-        built = list((REPO_ROOT / "host/static/dist/assets").glob("*.css"))
-        assert built, "no CSS emitted by the build"
-        combined = "\n".join(p.read_text(encoding="utf-8") for p in built)
-        assert "dashboard-stat-grid" in combined, (
-            "module-shipped CSS did not reach the bundle — the #module alias "
-            "most likely failed to resolve"
-        )