modelable 1.1.0__tar.gz → 1.2.0__tar.gz

{modelable-1.1.0 → modelable-1.2.0}/.gitignore

@@ -28,3 +28,6 @@ scripts/__pycache__/
 vscode/.vscode-test/
 vscode/out/
 vscode/*.vsix
+
+# Subagent-driven-development progress ledger (scratch state, not project output)
+.superpowers/

{modelable-1.1.0 → modelable-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modelable
-Version: 1.1.0
+Version: 1.2.0
 Summary: Compiler and language server for versioned, domain-owned data models
 Project-URL: Homepage, https://github.com/ktjn/modelable
 Project-URL: Documentation, https://ktjn.github.io/modelable/

{modelable-1.1.0 → modelable-1.2.0}/mypy-baseline.txt

@@ -34,11 +34,11 @@ src/modelable/compiler/workspace.py:215: error: Missing type arguments for gener
 src/modelable/compiler/workspace.py:223: error: Missing type arguments for generic type "tuple"  [type-arg]
 src/modelable/emitters/csharp.py:21: error: Incompatible types in assignment (expression has type "list[ProjectionVersion]", variable has type "list[ModelVersion]")  [assignment]
 src/modelable/emitters/csharp.py:23: error: Argument 3 to "_emit_projection" has incompatible type "ModelVersion"; expected "ProjectionVersion"  [arg-type]
-src/modelable/emitters/csharp.py:258: error: Function is missing a return type annotation  [no-untyped-def]
-src/modelable/emitters/csharp.py:258: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
-src/modelable/emitters/csharp.py:272: error: Item "ProjectionField" of "FieldDef | ProjectionField" has no attribute "optional"  [union-attr]
-src/modelable/emitters/csharp.py:272: error: Item "ProjectionField" of "FieldDef | ProjectionField" has no attribute "type"  [union-attr]
-src/modelable/emitters/csharp.py:75: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
+src/modelable/emitters/csharp.py:264: error: Function is missing a return type annotation  [no-untyped-def]
+src/modelable/emitters/csharp.py:264: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
+src/modelable/emitters/csharp.py:278: error: Item "ProjectionField" of "FieldDef | ProjectionField" has no attribute "optional"  [union-attr]
+src/modelable/emitters/csharp.py:278: error: Item "ProjectionField" of "FieldDef | ProjectionField" has no attribute "type"  [union-attr]
+src/modelable/emitters/csharp.py:81: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
 src/modelable/emitters/dbt_yaml.py:274: error: Item "ProjectionField" of "FieldDef | ProjectionField" has no attribute "type"  [union-attr]
 src/modelable/emitters/dbt_yaml.py:40: error: Incompatible types in assignment (expression has type "list[ProjectionVersion]", variable has type "list[ModelVersion]")  [assignment]
 src/modelable/emitters/dbt_yaml.py:42: error: Argument 3 to "_emit_projection" has incompatible type "ModelVersion"; expected "ProjectionVersion"  [arg-type]
@@ -137,31 +137,31 @@ src/modelable/emitters/rust.py:116: error: Missing type arguments for generic ty
 src/modelable/emitters/rust.py:128: error: Incompatible types in assignment (expression has type "list[ProjectionVersion]", variable has type "list[ModelVersion]")  [assignment]
 src/modelable/emitters/rust.py:130: error: "ModelVersion" has no attribute "source"  [attr-defined]
 src/modelable/emitters/rust.py:135: error: Argument 3 to "_emit_projection" has incompatible type "ModelVersion"; expected "ProjectionVersion"  [arg-type]
-src/modelable/emitters/rust.py:184: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
-src/modelable/emitters/rust.py:184: error: Missing type arguments for generic type "set"  [type-arg]
-src/modelable/emitters/rust.py:195: error: Missing type arguments for generic type "set"  [type-arg]
-src/modelable/emitters/rust.py:310: error: Missing type arguments for generic type "dict"  [type-arg]
-src/modelable/emitters/rust.py:366: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
-src/modelable/emitters/rust.py:375: error: Missing type arguments for generic type "dict"  [type-arg]
+src/modelable/emitters/rust.py:190: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
+src/modelable/emitters/rust.py:190: error: Missing type arguments for generic type "set"  [type-arg]
+src/modelable/emitters/rust.py:201: error: Missing type arguments for generic type "set"  [type-arg]
+src/modelable/emitters/rust.py:316: error: Missing type arguments for generic type "dict"  [type-arg]
+src/modelable/emitters/rust.py:372: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
+src/modelable/emitters/rust.py:381: error: Missing type arguments for generic type "dict"  [type-arg]
 src/modelable/emitters/rust.py:41: error: Missing type arguments for generic type "dict"  [type-arg]
-src/modelable/emitters/rust.py:461: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
+src/modelable/emitters/rust.py:467: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
 src/modelable/emitters/rust.py:56: error: Missing type arguments for generic type "frozenset"  [type-arg]
-src/modelable/emitters/rust.py:572: error: Missing type arguments for generic type "dict"  [type-arg]
-src/modelable/emitters/rust.py:729: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
-src/modelable/emitters/rust.py:776: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
-src/modelable/emitters/rust.py:805: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
-src/modelable/emitters/rust.py:831: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
-src/modelable/emitters/rust.py:845: error: Returning Any from function declared to return "str"  [no-any-return]
+src/modelable/emitters/rust.py:578: error: Missing type arguments for generic type "dict"  [type-arg]
+src/modelable/emitters/rust.py:735: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
+src/modelable/emitters/rust.py:782: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
+src/modelable/emitters/rust.py:811: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
+src/modelable/emitters/rust.py:837: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
+src/modelable/emitters/rust.py:851: error: Returning Any from function declared to return "str"  [no-any-return]
 src/modelable/emitters/rust.py:93: error: Item "dict[str, object]" of "dict[str, object] | str" has no attribute "rstrip"  [union-attr]
-src/modelable/emitters/rust.py:940: error: Function is missing a return type annotation  [no-untyped-def]
-src/modelable/emitters/rust.py:940: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
-src/modelable/emitters/rust.py:954: error: Item "ProjectionField" of "FieldDef | ProjectionField" has no attribute "optional"  [union-attr]
-src/modelable/emitters/rust.py:954: error: Item "ProjectionField" of "FieldDef | ProjectionField" has no attribute "type"  [union-attr]
-src/modelable/emitters/rust.py:958: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
-src/modelable/emitters/rust.py:958: error: Missing type arguments for generic type "dict"  [type-arg]
-src/modelable/emitters/rust.py:966: error: Returning Any from function declared to return "dict[Any, Any]"  [no-any-return]
-src/modelable/emitters/rust.py:971: error: Returning Any from function declared to return "dict[Any, Any]"  [no-any-return]
-src/modelable/emitters/rust.py:975: error: Returning Any from function declared to return "dict[Any, Any]"  [no-any-return]
+src/modelable/emitters/rust.py:946: error: Function is missing a return type annotation  [no-untyped-def]
+src/modelable/emitters/rust.py:946: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
+src/modelable/emitters/rust.py:960: error: Item "ProjectionField" of "FieldDef | ProjectionField" has no attribute "optional"  [union-attr]
+src/modelable/emitters/rust.py:960: error: Item "ProjectionField" of "FieldDef | ProjectionField" has no attribute "type"  [union-attr]
+src/modelable/emitters/rust.py:964: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
+src/modelable/emitters/rust.py:964: error: Missing type arguments for generic type "dict"  [type-arg]
+src/modelable/emitters/rust.py:972: error: Returning Any from function declared to return "dict[Any, Any]"  [no-any-return]
+src/modelable/emitters/rust.py:977: error: Returning Any from function declared to return "dict[Any, Any]"  [no-any-return]
+src/modelable/emitters/rust.py:981: error: Returning Any from function declared to return "dict[Any, Any]"  [no-any-return]
 src/modelable/emitters/sql.py:196: error: Function is missing a return type annotation  [no-untyped-def]
 src/modelable/emitters/sql.py:196: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
 src/modelable/emitters/sql.py:211: error: Function is missing a return type annotation  [no-untyped-def]

{modelable-1.1.0 → modelable-1.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "modelable"
-version = "1.1.0"
+version = "1.2.0"
 description = "Compiler and language server for versioned, domain-owned data models"
 readme = "README.md"
 license = "Apache-2.0"

{modelable-1.1.0 → modelable-1.2.0}/src/modelable/commands/compile.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import dataclasses
 import json
 import sys
 from pathlib import Path
@@ -26,6 +27,7 @@ from modelable.emitters.rust import emit_rust
 from modelable.emitters.sql import emit_sql
 from modelable.emitters.targets import list_implemented_codegen_targets
 from modelable.emitters.typescript import emit_typescript
+from modelable.parser.ir import ArrayType, FieldType, MapType, MdlFile, NamedType, ObjectType
 from modelable.planner.plans import write_plans
 from modelable.registry.factory import get_registry
 from modelable.registry.ids import allocate_registry_ids, read_lock_file, write_lock_file
@@ -39,6 +41,75 @@ _DEFAULT_OUT_DIRS: dict[str, Path] = {
 }
 
 
+def _collect_named_type_names(field_type: FieldType, result: set[str]) -> None:
+    """Recursively collect NamedType names referenced by a field type."""
+    if isinstance(field_type, NamedType):
+        result.add(field_type.name)
+    elif isinstance(field_type, ArrayType):
+        _collect_named_type_names(field_type.item, result)
+    elif isinstance(field_type, MapType):
+        _collect_named_type_names(field_type.value, result)
+    elif isinstance(field_type, ObjectType):
+        for field in field_type.fields:
+            _collect_named_type_names(field.type, result)
+
+
+def _domain_defining(mdl: MdlFile, name: str) -> str | None:
+    """Return the name of the domain that defines a model or semantic type, or None."""
+    for domain in mdl.domains:
+        if name in domain.models:
+            return domain.name
+        if any(decl.name == name for decl in domain.semantic_types):
+            return domain.name
+    return None
+
+
+def _find_domain_scope_violations(mdl: MdlFile, requested: set[str]) -> list[str]:
+    """Find dependencies of requested domains that resolve only outside the requested set.
+
+    Checks both NamedType field references (recursively, across arrays/maps/nested
+    objects) and projection source/join model references. Uses the full, unfiltered
+    `mdl` to resolve where a dependency actually lives, so a reference to a domain
+    that isn't part of the workspace at all is left alone (that is `validate`'s job,
+    not this filter's).
+    """
+    violations: list[str] = []
+    for domain in mdl.domains:
+        if domain.name not in requested:
+            continue
+        for model_name, versions in domain.models.items():
+            for version in versions:
+                for field in version.fields:
+                    names: set[str] = set()
+                    _collect_named_type_names(field.type, names)
+                    for name in names:
+                        target_domain = _domain_defining(mdl, name)
+                        if (
+                            target_domain is not None
+                            and target_domain != domain.name
+                            and target_domain not in requested
+                        ):
+                            violations.append(
+                                f"{domain.name}.{model_name}@{version.version} field '{field.name}' "
+                                f"references type '{name}' defined in domain '{target_domain}', "
+                                "which is excluded by --domain"
+                            )
+        for projection_name, proj_versions in domain.projections.items():
+            for proj_version in proj_versions:
+                ref_models = [proj_version.source.model, *(join.model for join in proj_version.joins)]
+                for ref_model in ref_models:
+                    try:
+                        source_domain, _ = ref_model.rsplit(".", 1)
+                    except ValueError:
+                        continue
+                    if source_domain != domain.name and source_domain not in requested:
+                        violations.append(
+                            f"{domain.name}.{projection_name}@{proj_version.version} references "
+                            f"'{ref_model}' in domain '{source_domain}', which is excluded by --domain"
+                        )
+    return violations
+
+
 def register_compile_commands(cli_group: click.Group) -> None:
     cli_group.add_command(compile)
     cli_group.add_command(docs)
@@ -78,6 +149,13 @@ def register_compile_commands(cli_group: click.Group) -> None:
     is_flag=True,
     help="Tolerate ledger entries with no matching 'registry: true' declaration instead of erroring.",
 )
+@click.option(
+    "--domain",
+    "domains",
+    multiple=True,
+    default=(),
+    help="Restrict compilation to the named domain(s) (repeatable). Omit to compile the whole workspace.",
+)
 def compile(
     source: Path,
     target: str,
@@ -85,10 +163,34 @@ def compile(
     registry_path: str,
     registry_ids_path: Path,
     allow_orphaned_registry_ids: bool,
+    domains: tuple[str, ...],
 ) -> None:
     """Compile Modelable definitions and write the local registry index."""
     workspace = load_workspace_or_exit(source)
 
+    emit_workspace = workspace
+    if domains:
+        known_domains = {d.name for d in workspace.mdl.domains}
+        unknown_domains = sorted(set(domains) - known_domains)
+        if unknown_domains:
+            raise click.ClickException(
+                f"Unknown --domain value(s): {', '.join(unknown_domains)}. "
+                f"Available domains: {', '.join(sorted(known_domains))}"
+            )
+        requested = set(domains)
+        violations = _find_domain_scope_violations(workspace.mdl, requested)
+        if violations:
+            raise click.ClickException(
+                "Cannot scope compilation with --domain: the requested domain(s) have "
+                "dependencies outside the requested set:\n"
+                + "\n".join(f"  - {v}" for v in violations)
+                + "\nAdd the missing domain(s) to --domain, or narrow the requested set."
+            )
+        scoped_domains = [d for d in workspace.mdl.domains if d.name in domains]
+        emit_workspace = dataclasses.replace(
+            workspace, mdl=workspace.mdl.model_copy(update={"domains": scoped_domains})
+        )
+
     existing_registry_ids = read_lock_file(registry_ids_path)
     try:
         registry_ids = allocate_registry_ids(
@@ -119,14 +221,14 @@ def compile(
     output.mkdir(parents=True, exist_ok=True)
 
     if target == "json-schema":
-        artifacts = emit_json_schema(workspace, output)
+        artifacts = emit_json_schema(emit_workspace, output)
         for art in artifacts:
             _write_artifact_text(art.path, json.dumps(art.content, indent=2, ensure_ascii=False) + "\n")
             _print_artifact_result(art)
         if not artifacts:
             console.print("[yellow]No artifacts generated.[/yellow]")
     elif target == "markdown":
-        artifacts = emit_markdown(workspace, output)
+        artifacts = emit_markdown(emit_workspace, output)
         for art in artifacts:
             assert isinstance(art.content, str)
             _write_artifact_text(art.path, art.content)
@@ -134,7 +236,7 @@ def compile(
         if not artifacts:
             console.print("[yellow]No artifacts generated.[/yellow]")
     elif target == "typescript":
-        artifacts = emit_typescript(workspace, output)
+        artifacts = emit_typescript(emit_workspace, output)
         for art in artifacts:
             assert isinstance(art.content, str)
             _write_artifact_text(art.path, art.content)
@@ -142,7 +244,7 @@ def compile(
         if not artifacts:
             console.print("[yellow]No artifacts generated.[/yellow]")
     elif target == "csharp":
-        artifacts = emit_csharp(workspace, output)
+        artifacts = emit_csharp(emit_workspace, output)
         for art in artifacts:
             assert isinstance(art.content, str)
             _write_artifact_text(art.path, art.content)
@@ -150,7 +252,7 @@ def compile(
         if not artifacts:
             console.print("[yellow]No artifacts generated.[/yellow]")
     elif target == "java":
-        artifacts = emit_java(workspace, output)
+        artifacts = emit_java(emit_workspace, output)
         for art in artifacts:
             assert isinstance(art.content, str)
             _write_artifact_text(art.path, art.content)
@@ -158,7 +260,7 @@ def compile(
         if not artifacts:
             console.print("[yellow]No artifacts generated.[/yellow]")
     elif target == "python":
-        artifacts = emit_python(workspace, output)
+        artifacts = emit_python(emit_workspace, output)
         for art in artifacts:
             assert isinstance(art.content, str)
             _write_artifact_text(art.path, art.content)
@@ -166,7 +268,7 @@ def compile(
         if not artifacts:
             console.print("[yellow]No artifacts generated.[/yellow]")
     elif target == "rust":
-        artifacts = emit_rust(workspace, output, registry_ids=registry_ids)
+        artifacts = emit_rust(emit_workspace, output, registry_ids=registry_ids)
         for art in artifacts:
             assert isinstance(art.content, str)
             _write_artifact_text(art.path, art.content)
@@ -174,7 +276,7 @@ def compile(
         if not artifacts:
             console.print("[yellow]No artifacts generated.[/yellow]")
     elif target == "go":
-        artifacts = emit_go(workspace, output)
+        artifacts = emit_go(emit_workspace, output)
         for art in artifacts:
             assert isinstance(art.content, str)
             _write_artifact_text(art.path, art.content)
@@ -182,7 +284,7 @@ def compile(
         if not artifacts:
             console.print("[yellow]No artifacts generated.[/yellow]")
     elif target == "dbt-yaml":
-        artifacts = emit_dbt_yaml(workspace, output)
+        artifacts = emit_dbt_yaml(emit_workspace, output)
         for art in artifacts:
             assert isinstance(art.content, str)
             _write_artifact_text(art.path, art.content)
@@ -190,7 +292,7 @@ def compile(
         if not artifacts:
             console.print("[yellow]No artifacts generated.[/yellow]")
     elif target == "fhir-profile":
-        artifacts = emit_fhir_profile(workspace, output)
+        artifacts = emit_fhir_profile(emit_workspace, output)
         for art in artifacts:
             assert isinstance(art.content, str)
             _write_artifact_text(art.path, art.content)
@@ -198,7 +300,7 @@ def compile(
         if not artifacts:
             console.print("[yellow]No artifacts generated.[/yellow]")
     elif target == "openmetadata":
-        artifacts = emit_openmetadata(workspace, output)
+        artifacts = emit_openmetadata(emit_workspace, output)
         for art in artifacts:
             content = (
                 json.dumps(art.content, indent=2, ensure_ascii=False) + "\n"
@@ -211,7 +313,7 @@ def compile(
         if not artifacts:
             console.print("[yellow]No artifacts generated.[/yellow]")
     elif target == "openlineage":
-        artifacts = emit_openlineage(workspace, output)
+        artifacts = emit_openlineage(emit_workspace, output)
         for art in artifacts:
             assert isinstance(art.content, dict)
             _write_artifact_text(art.path, json.dumps(art.content, indent=2, ensure_ascii=False) + "\n")
@@ -219,7 +321,7 @@ def compile(
         if not artifacts:
             console.print("[yellow]No artifacts generated.[/yellow]")
     elif target == "odcs":
-        artifacts = emit_odcs(workspace, output)
+        artifacts = emit_odcs(emit_workspace, output)
         for art in artifacts:
             assert isinstance(art.content, str)
             _write_artifact_text(art.path, art.content)
@@ -227,7 +329,7 @@ def compile(
         if not artifacts:
             console.print("[yellow]No artifacts generated.[/yellow]")
     elif target == "protobuf":
-        artifacts = emit_protobuf(workspace, output)
+        artifacts = emit_protobuf(emit_workspace, output)
         for art in artifacts:
             assert isinstance(art.content, str)
             _write_artifact_text(art.path, art.content)
@@ -235,7 +337,7 @@ def compile(
         if not artifacts:
             console.print("[yellow]No artifacts generated.[/yellow]")
     elif target == "grpc":
-        artifacts = emit_grpc(workspace, output)
+        artifacts = emit_grpc(emit_workspace, output)
         for art in artifacts:
             assert isinstance(art.content, str)
             _write_artifact_text(art.path, art.content)
@@ -244,7 +346,7 @@ def compile(
             console.print("[yellow]No artifacts generated.[/yellow]")
     elif target in ("sql-postgres", "sql-clickhouse"):
         dialect = target.removeprefix("sql-")
-        artifacts = emit_sql(workspace, output, dialect)
+        artifacts = emit_sql(emit_workspace, output, dialect)
         for art in artifacts:
             assert isinstance(art.content, str)
             _write_artifact_text(art.path, art.content)

{modelable-1.1.0 → modelable-1.2.0}/src/modelable/emitters/csharp.py

@@ -30,7 +30,13 @@ def _artifact_id(domain: str, name: str, version: int) -> str:
 
 def _pascalize(value: str) -> str:
     parts = [part for part in re.split(r"[^A-Za-z0-9]+", value) if part]
-    return "".join(part[:1].upper() + part[1:] for part in parts) or "Generated"
+
+    def _title(part: str) -> str:
+        if part.isupper():
+            return part[:1] + part[1:].lower()
+        return part[:1].upper() + part[1:]
+
+    return "".join(_title(part) for part in parts) or "Generated"
 
 
 def _namespace_name(domain: str) -> str:

{modelable-1.1.0 → modelable-1.2.0}/src/modelable/emitters/rust.py

@@ -167,7 +167,13 @@ def _artifact_id(domain: str, name: str, version: int) -> str:
 
 def _pascalize(value: str) -> str:
     parts = [part for part in re.split(r"[^A-Za-z0-9]+", value) if part]
-    return "".join(part[:1].upper() + part[1:] for part in parts) or "Generated"
+
+    def _title(part: str) -> str:
+        if part.isupper():
+            return part[:1] + part[1:].lower()
+        return part[:1].upper() + part[1:]
+
+    return "".join(_title(part) for part in parts) or "Generated"
 
 
 def _snake_case(value: str) -> str:

modelable-1.2.0/tests/test_cli_compile.py

@@ -0,0 +1,174 @@
+from __future__ import annotations
+
+from click.testing import CliRunner
+
+from modelable.cli import cli
+
+_TWO_DOMAIN_MDL = """
+domain logs {
+  owner: "test-team"
+  entity LogEntry @ 1 (additive) {
+    @key logId: uuid
+    message: string
+  }
+}
+
+domain nlq {
+  owner: "test-team"
+  entity Query @ 1 (additive) {
+    @key queryId: uuid
+    text: string
+  }
+}
+"""
+
+
+def test_compile_domain_flag_restricts_output(tmp_path):
+    mdl = tmp_path / "workspace.mdl"
+    mdl.write_text(_TWO_DOMAIN_MDL, encoding="utf-8")
+    out = tmp_path / "dist" / "rust"
+
+    runner = CliRunner()
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        result = runner.invoke(
+            cli,
+            ["compile", str(mdl), "--target", "rust", "--domain", "logs", "--out", str(out)],
+        )
+
+    assert result.exit_code == 0, result.output
+    assert (out / "logs" / "logs_log_entry_v1.rs").exists()
+    assert not (out / "nlq").exists()
+
+
+def test_compile_domain_flag_is_additive(tmp_path):
+    mdl = tmp_path / "workspace.mdl"
+    mdl.write_text(_TWO_DOMAIN_MDL, encoding="utf-8")
+    out = tmp_path / "dist" / "rust"
+
+    runner = CliRunner()
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        result = runner.invoke(
+            cli,
+            [
+                "compile",
+                str(mdl),
+                "--target",
+                "rust",
+                "--domain",
+                "logs",
+                "--domain",
+                "nlq",
+                "--out",
+                str(out),
+            ],
+        )
+
+    assert result.exit_code == 0, result.output
+    assert (out / "logs" / "logs_log_entry_v1.rs").exists()
+    assert (out / "nlq" / "nlq_query_v1.rs").exists()
+
+
+def test_compile_unknown_domain_errors_clearly(tmp_path):
+    mdl = tmp_path / "workspace.mdl"
+    mdl.write_text(_TWO_DOMAIN_MDL, encoding="utf-8")
+    out = tmp_path / "dist" / "rust"
+
+    runner = CliRunner()
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        result = runner.invoke(
+            cli,
+            ["compile", str(mdl), "--target", "rust", "--domain", "bogus", "--out", str(out)],
+        )
+
+    assert result.exit_code != 0
+    assert "bogus" in result.output
+    assert "logs" in result.output
+    assert "nlq" in result.output
+    assert not out.exists()
+
+
+def test_compile_without_domain_flag_compiles_whole_workspace(tmp_path):
+    mdl = tmp_path / "workspace.mdl"
+    mdl.write_text(_TWO_DOMAIN_MDL, encoding="utf-8")
+    out = tmp_path / "dist" / "rust"
+
+    runner = CliRunner()
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        result = runner.invoke(
+            cli,
+            ["compile", str(mdl), "--target", "rust", "--out", str(out)],
+        )
+
+    assert result.exit_code == 0, result.output
+    assert (out / "logs" / "logs_log_entry_v1.rs").exists()
+    assert (out / "nlq" / "nlq_query_v1.rs").exists()
+
+
+_CROSS_DOMAIN_PROJECTION_MDL = """
+domain customer {
+  owner: "test-team"
+  entity Customer @ 1 (additive) {
+    @key customerId: uuid
+    displayName: string
+  }
+}
+
+domain billing {
+  owner: "test-team"
+
+  projection BillingCustomer @ 1
+    from customer.Customer @ 1 as c
+  {
+    customerId <- c.customerId
+    displayName <- c.displayName
+  }
+}
+"""
+
+
+def test_compile_domain_flag_errors_on_excluded_projection_source(tmp_path):
+    mdl = tmp_path / "workspace.mdl"
+    mdl.write_text(_CROSS_DOMAIN_PROJECTION_MDL, encoding="utf-8")
+    out = tmp_path / "dist" / "rust"
+
+    runner = CliRunner()
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        result = runner.invoke(
+            cli,
+            ["compile", str(mdl), "--target", "rust", "--domain", "billing", "--out", str(out)],
+        )
+
+    assert result.exit_code != 0
+    assert "customer" in result.output
+    assert "billing.BillingCustomer" in result.output
+    assert not out.exists()
+
+
+def test_compile_domain_flag_succeeds_when_projection_source_included(tmp_path):
+    mdl = tmp_path / "workspace.mdl"
+    mdl.write_text(_CROSS_DOMAIN_PROJECTION_MDL, encoding="utf-8")
+    out = tmp_path / "dist" / "rust"
+
+    runner = CliRunner()
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        result = runner.invoke(
+            cli,
+            [
+                "compile",
+                str(mdl),
+                "--target",
+                "rust",
+                "--domain",
+                "billing",
+                "--domain",
+                "customer",
+                "--out",
+                str(out),
+            ],
+        )
+
+    assert result.exit_code == 0, result.output
+    text = (out / "billing" / "billing_billing_customer_v1.rs").read_text(encoding="utf-8")
+    # The projection field must keep the source's real type (uuid), not degrade to a lossy String.
+    assert "pub customer_id: uuid::Uuid," in text
+    assert "pub customer_id: String," not in text

{modelable-1.1.0 → modelable-1.2.0}/tests/test_emit_csharp.py

@@ -7,6 +7,15 @@ from modelable.compiler.workspace import load_workspace
 from modelable.emitters.csharp import emit_csharp
 
 
+def test_pascalize_titlecases_all_uppercase_tokens():
+    from modelable.emitters.csharp import _pascalize
+
+    assert _pascalize("INTERNAL") == "Internal"
+    assert _pascalize("SERVER_CLIENT") == "ServerClient"
+    assert _pascalize("AlreadyPascalCase") == "AlreadyPascalCase"
+    assert _pascalize("camelCase") == "CamelCase"
+
+
 def test_emit_csharp_model_and_projection(tmp_path):
     mdl = tmp_path / "test.mdl"
     mdl.write_text(

{modelable-1.1.0 → modelable-1.2.0}/tests/test_emit_rust.py

@@ -1169,6 +1169,43 @@ domain telecom {
     assert "    3gpp," not in art.content
 
 
+def test_pascalize_titlecases_all_uppercase_tokens():
+    from modelable.emitters.rust import _pascalize
+
+    assert _pascalize("INTERNAL") == "Internal"
+    assert _pascalize("SERVER_CLIENT") == "ServerClient"
+    assert _pascalize("AlreadyPascalCase") == "AlreadyPascalCase"
+    assert _pascalize("camelCase") == "CamelCase"
+
+
+def test_emit_rust_screaming_snake_case_enum_value_becomes_pascal_case(tmp_path):
+    (tmp_path / "model.mdl").write_text(
+        """
+domain tracing {
+  owner: "test-team"
+  entity Span @ 1 (additive) {
+    @key spanId: uuid
+    spanKind: enum(INTERNAL, SERVER, CLIENT, PRODUCER, CONSUMER)
+  }
+}
+""",
+        encoding="utf-8",
+    )
+    workspace = load_workspace(tmp_path)
+    artifacts = emit_rust(workspace, tmp_path / "out")
+    art = next(a for a in artifacts if a.ref == "tracing.Span@1")
+    # Rust variant names are idiomatic PascalCase, not the raw wire casing
+    assert "Internal," in art.content
+    assert "Server," in art.content
+    assert "Client," in art.content
+    assert "Producer," in art.content
+    assert "Consumer," in art.content
+    assert "INTERNAL," not in art.content
+    # The wire value is preserved via serde rename so the wire contract doesn't shift
+    assert '#[serde(rename = "INTERNAL")]' in art.content
+    assert '#[serde(rename = "SERVER")]' in art.content
+
+
 def test_emit_rust_wire_rust_type_applies_to_array_element(tmp_path):
     (tmp_path / "model.mdl").write_text(
         """
@@ -1444,6 +1481,6 @@ binding span-binding {
     proj = next(a for a in artifacts if a.ref == "telemetry.SpanRow@1")
     # Match arm generated for enum → String conversion
     assert "span_kind: match src.span_kind {" in proj.content
-    assert 'TelemetrySpanV1SpanKind::INTERNAL => "INTERNAL".to_string(),' in proj.content
+    assert 'TelemetrySpanV1SpanKind::Internal => "INTERNAL".to_string(),' in proj.content
     # Must NOT use .into() for the enum field
     assert "span_kind: src.span_kind.into()," not in proj.content

{modelable-1.1.0 → modelable-1.2.0}/uv.lock

@@ -348,7 +348,7 @@ wheels = [
 
 [[package]]
 name = "modelable"
-version = "1.1.0"
+version = "1.2.0"
 source = { editable = "." }
 dependencies = [
     { name = "click" },