sdcvalidator 4.1.0__tar.gz → 4.2.1__tar.gz

{sdcvalidator-4.1.0/src/sdcvalidator.egg-info → sdcvalidator-4.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sdcvalidator
-Version: 4.1.0
+Version: 4.2.1
 Summary: SDC4 structural validator — thin wrapper over xmlschema with error classification
 Author: Semantic Data Charter Foundation
 License-Expression: Apache-2.0
@@ -32,6 +32,7 @@ Dynamic: license-file
 - Validates XML instances against SDC4 XSD schemas
 - Classifies errors into **structural** (Tier 1: reject) vs **semantic** (Tier 2: report)
 - Checks SDC4 schema compliance (no `xsd:extension` — only `xsd:restriction`)
+- **Strict validation by default** — catches invalid restriction derivations (wrong element names, type mismatches) at schema load time
 - Converts between XML and JSON using schema-aware conversion
 
 ## Install
@@ -53,7 +54,7 @@ pip install -e .
 ```python
 from sdcvalidator import SDC4Validator, ErrorTier
 
-# Validate an XML instance
+# Validate an XML instance (strict mode by default)
 validator = SDC4Validator("my_schema.xsd")
 result = validator.validate("my_instance.xml")
 
@@ -66,6 +67,19 @@ else:
         print(f"SEMANTIC: {err.reason}")
 ```
 
+### Validation modes
+
+The `validation` parameter controls how strictly the XSD schema itself is checked when loaded:
+
+- **`'strict'`** (default) — Raises `XMLSchemaParseError` if the schema contains invalid restriction derivations (e.g., element names that don't match the base type). This is the recommended mode.
+- **`'lax'`** — Silently collects schema derivation errors without raising. Use only for pre-existing schemas known to have issues.
+- **`'skip'`** — Skips schema-level validation entirely.
+
+```python
+# Explicit lax mode for legacy schemas
+validator = SDC4Validator("legacy_schema.xsd", validation='lax')
+```
+
 ### Schema compliance checking
 
 ```python

{sdcvalidator-4.1.0 → sdcvalidator-4.2.1}/README.md

@@ -10,6 +10,7 @@
 - Validates XML instances against SDC4 XSD schemas
 - Classifies errors into **structural** (Tier 1: reject) vs **semantic** (Tier 2: report)
 - Checks SDC4 schema compliance (no `xsd:extension` — only `xsd:restriction`)
+- **Strict validation by default** — catches invalid restriction derivations (wrong element names, type mismatches) at schema load time
 - Converts between XML and JSON using schema-aware conversion
 
 ## Install
@@ -31,7 +32,7 @@ pip install -e .
 ```python
 from sdcvalidator import SDC4Validator, ErrorTier
 
-# Validate an XML instance
+# Validate an XML instance (strict mode by default)
 validator = SDC4Validator("my_schema.xsd")
 result = validator.validate("my_instance.xml")
 
@@ -44,6 +45,19 @@ else:
         print(f"SEMANTIC: {err.reason}")
 ```
 
+### Validation modes
+
+The `validation` parameter controls how strictly the XSD schema itself is checked when loaded:
+
+- **`'strict'`** (default) — Raises `XMLSchemaParseError` if the schema contains invalid restriction derivations (e.g., element names that don't match the base type). This is the recommended mode.
+- **`'lax'`** — Silently collects schema derivation errors without raising. Use only for pre-existing schemas known to have issues.
+- **`'skip'`** — Skips schema-level validation entirely.
+
+```python
+# Explicit lax mode for legacy schemas
+validator = SDC4Validator("legacy_schema.xsd", validation='lax')
+```
+
 ### Schema compliance checking
 
 ```python

{sdcvalidator-4.1.0 → sdcvalidator-4.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sdcvalidator"
-version = "4.1.0"
+version = "4.2.1"
 description = "SDC4 structural validator — thin wrapper over xmlschema with error classification"
 license = "Apache-2.0"
 requires-python = ">=3.10"
@@ -30,6 +30,7 @@ dev = ["pytest>=7.0", "pytest-cov"]
 sdcvalidate = "sdcvalidator.cli:validate_main"
 sdcvalidator-xml2json = "sdcvalidator.cli:xml2json_main"
 sdcvalidator-json2xml = "sdcvalidator.cli:json2xml_main"
+sdcvalidator-mcp = "sdcvalidator.mcp_server:main"
 
 [tool.setuptools.packages.find]
 where = ["src"]

{sdcvalidator-4.1.0 → sdcvalidator-4.2.1}/src/sdcvalidator/__init__.py

@@ -13,7 +13,7 @@ sdcvalidator — SDC4 structural validator.
 Thin wrapper over xmlschema with two-tier error classification.
 """
 
-__version__ = "4.1.0"
+__version__ = "4.2.1"
 
 from .validator import SDC4Validator, ValidationResult
 from .error_classifier import ErrorClassifier

sdcvalidator-4.2.1/src/sdcvalidator/mcp_server.py

@@ -0,0 +1,295 @@
+#
+# Copyright 2026 Semantic Data Charter Foundation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+"""
+MCP server exposing sdcvalidator tools to any agent framework.
+
+Implements the MCP (Model Context Protocol) as a raw JSON-RPC 2.0
+stdio server. No external MCP SDK dependency.
+
+Start the server::
+
+    sdcvalidator serve --mcp
+
+MCP Tools exposed:
+- validate_instance: validate an XML instance against its XSD schema
+- validate_and_report: detailed validation report with error classification
+- check_schema_compliance: verify schema follows SDC4 principles
+
+Protocol: JSON-RPC 2.0 over stdio (one JSON object per line).
+"""
+
+import json
+import sys
+from typing import Any
+
+from sdcvalidator.validator import SDC4Validator
+from sdcvalidator.schema_checker import validate_sdc4_schema_compliance
+
+# Protocol constants
+JSONRPC_VERSION = "2.0"
+MCP_PROTOCOL_VERSION = "2024-11-05"
+SERVER_NAME = "sdcvalidator"
+SERVER_VERSION = "4.2.1"
+
+# Validator cache: schema_path -> SDC4Validator
+_validators: dict[str, SDC4Validator] = {}
+
+
+def _get_validator(schema_path: str, check_compliance: bool = True) -> SDC4Validator:
+    """Get or create a validator for the given schema."""
+    key = f"{schema_path}:{check_compliance}"
+    if key not in _validators:
+        _validators[key] = SDC4Validator(
+            schema_path,
+            check_sdc4_compliance=check_compliance,
+        )
+    return _validators[key]
+
+
+# --- Tool definitions ---
+
+TOOLS = [
+    {
+        "name": "validate_instance",
+        "description": (
+            "Validate an XML instance against its SDC4 XSD schema. "
+            "Returns pass/fail with error count and classified errors."
+        ),
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "schema_path": {
+                    "type": "string",
+                    "description": "Path to the SDC4 data model XSD file.",
+                },
+                "instance_path": {
+                    "type": "string",
+                    "description": "Path to the XML instance file to validate.",
+                },
+                "check_compliance": {
+                    "type": "boolean",
+                    "description": "Check schema follows SDC4 principles (no xsd:extension). Default true.",
+                    "default": True,
+                },
+            },
+            "required": ["schema_path", "instance_path"],
+        },
+    },
+    {
+        "name": "validate_and_report",
+        "description": (
+            "Validate an XML instance and return a detailed report with "
+            "two-tier error classification (structural vs semantic)."
+        ),
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "schema_path": {
+                    "type": "string",
+                    "description": "Path to the SDC4 data model XSD file.",
+                },
+                "instance_path": {
+                    "type": "string",
+                    "description": "Path to the XML instance file to validate.",
+                },
+                "check_compliance": {
+                    "type": "boolean",
+                    "description": "Check schema follows SDC4 principles. Default true.",
+                    "default": True,
+                },
+            },
+            "required": ["schema_path", "instance_path"],
+        },
+    },
+    {
+        "name": "check_schema_compliance",
+        "description": (
+            "Check if an XSD schema follows SDC4 principles "
+            "(no xsd:extension, restriction only). Does not validate instances."
+        ),
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "schema_path": {
+                    "type": "string",
+                    "description": "Path to the XSD schema file to check.",
+                },
+            },
+            "required": ["schema_path"],
+        },
+    },
+]
+
+
+# --- Tool handlers ---
+
+def _handle_validate_instance(args: dict[str, Any]) -> Any:
+    schema_path = args["schema_path"]
+    instance_path = args["instance_path"]
+    check_compliance = args.get("check_compliance", True)
+
+    try:
+        validator = _get_validator(schema_path, check_compliance)
+    except Exception as exc:
+        return {
+            "valid": False,
+            "error": f"Schema error: {exc}",
+            "error_count": 0,
+        }
+
+    result = validator.validate(instance_path)
+    return {
+        "valid": result.is_valid,
+        "error_count": result.error_count,
+        "structural_error_count": len(result.structural_errors),
+        "semantic_error_count": len(result.semantic_errors),
+    }
+
+
+def _handle_validate_and_report(args: dict[str, Any]) -> Any:
+    schema_path = args["schema_path"]
+    instance_path = args["instance_path"]
+    check_compliance = args.get("check_compliance", True)
+
+    try:
+        validator = _get_validator(schema_path, check_compliance)
+    except Exception as exc:
+        return {
+            "valid": False,
+            "error": f"Schema error: {exc}",
+            "error_count": 0,
+            "structural_errors": [],
+            "semantic_errors": [],
+        }
+
+    return validator.validate_and_report(instance_path)
+
+
+def _handle_check_schema_compliance(args: dict[str, Any]) -> Any:
+    schema_path = args["schema_path"]
+    is_valid, errors = validate_sdc4_schema_compliance(schema_path)
+    return {
+        "compliant": is_valid,
+        "errors": errors,
+    }
+
+
+TOOL_HANDLERS = {
+    "validate_instance": _handle_validate_instance,
+    "validate_and_report": _handle_validate_and_report,
+    "check_schema_compliance": _handle_check_schema_compliance,
+}
+
+
+# --- JSON-RPC 2.0 stdio server ---
+
+def _jsonrpc_response(id: Any, result: Any) -> dict:
+    return {"jsonrpc": JSONRPC_VERSION, "id": id, "result": result}
+
+
+def _jsonrpc_error(id: Any, code: int, message: str, data: Any = None) -> dict:
+    error = {"code": code, "message": message}
+    if data is not None:
+        error["data"] = data
+    return {"jsonrpc": JSONRPC_VERSION, "id": id, "error": error}
+
+
+def _handle_request(request: dict) -> dict | None:
+    method = request.get("method", "")
+    params = request.get("params", {})
+    req_id = request.get("id")
+
+    if method == "initialize":
+        result = {
+            "protocolVersion": MCP_PROTOCOL_VERSION,
+            "capabilities": {"tools": {"listChanged": False}},
+            "serverInfo": {"name": SERVER_NAME, "version": SERVER_VERSION},
+            "instructions": (
+                "SDC4 structural validator. Validates XML instances against "
+                "XSD schemas with two-tier error classification (structural vs semantic). "
+                "Independent from sdcgovernance - agents call each library separately."
+            ),
+        }
+        return _jsonrpc_response(req_id, result)
+
+    elif method == "notifications/initialized":
+        return None
+
+    elif method == "tools/list":
+        return _jsonrpc_response(req_id, {"tools": TOOLS})
+
+    elif method == "tools/call":
+        tool_name = params.get("name", "")
+        tool_args = params.get("arguments", {})
+
+        handler = TOOL_HANDLERS.get(tool_name)
+        if handler is None:
+            return _jsonrpc_error(req_id, -32601, f"Unknown tool: {tool_name}")
+
+        try:
+            result = handler(tool_args)
+            return _jsonrpc_response(req_id, {
+                "content": [{"type": "text", "text": json.dumps(result, default=str)}],
+            })
+        except Exception as exc:
+            return _jsonrpc_error(req_id, -32000, f"Tool execution error: {exc}")
+
+    elif method == "ping":
+        return _jsonrpc_response(req_id, {})
+
+    else:
+        if req_id is not None:
+            return _jsonrpc_error(req_id, -32601, f"Method not found: {method}")
+        return None
+
+
+def run_stdio() -> None:
+    """Run the MCP server on stdio."""
+    for line in sys.stdin:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            request = json.loads(line)
+        except json.JSONDecodeError as exc:
+            response = _jsonrpc_error(None, -32700, f"Parse error: {exc}")
+            sys.stdout.write(json.dumps(response) + "\n")
+            sys.stdout.flush()
+            continue
+
+        response = _handle_request(request)
+        if response is not None:
+            sys.stdout.write(json.dumps(response) + "\n")
+            sys.stdout.flush()
+
+
+def main() -> None:
+    """Entry point for the sdcvalidator MCP server."""
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        prog="sdcvalidator-mcp",
+        description="SDC4 structural validator - MCP server",
+    )
+    subparsers = parser.add_subparsers(dest="command")
+
+    serve_parser = subparsers.add_parser("serve", help="Start the validation server")
+    serve_parser.add_argument("--mcp", action="store_true", help="Run as MCP stdio server")
+
+    args = parser.parse_args()
+
+    if args.command == "serve" and args.mcp:
+        run_stdio()
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

{sdcvalidator-4.1.0 → sdcvalidator-4.2.1}/src/sdcvalidator/validator.py

@@ -52,7 +52,7 @@ class SDC4Validator:
         self,
         schema: Union[str, Path, XMLSchema11],
         check_sdc4_compliance: bool = True,
-        validation: str = 'lax',
+        validation: str = 'strict',
     ):
         """
         Initialize the SDC4 validator.
@@ -62,6 +62,9 @@ class SDC4Validator:
             check_sdc4_compliance: If True, validate schema follows SDC4
                 principles (no xsd:extension). Default: True.
             validation: Schema validation mode ('strict', 'lax', 'skip').
+                Default is 'strict' to catch invalid restriction derivations
+                (e.g. wrong element names, type mismatches). Lax mode silently
+                accepts these errors.
 
         Raises:
             SDC4SchemaValidationError: If compliance check fails.

{sdcvalidator-4.1.0 → sdcvalidator-4.2.1/src/sdcvalidator.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sdcvalidator
-Version: 4.1.0
+Version: 4.2.1
 Summary: SDC4 structural validator — thin wrapper over xmlschema with error classification
 Author: Semantic Data Charter Foundation
 License-Expression: Apache-2.0
@@ -32,6 +32,7 @@ Dynamic: license-file
 - Validates XML instances against SDC4 XSD schemas
 - Classifies errors into **structural** (Tier 1: reject) vs **semantic** (Tier 2: report)
 - Checks SDC4 schema compliance (no `xsd:extension` — only `xsd:restriction`)
+- **Strict validation by default** — catches invalid restriction derivations (wrong element names, type mismatches) at schema load time
 - Converts between XML and JSON using schema-aware conversion
 
 ## Install
@@ -53,7 +54,7 @@ pip install -e .
 ```python
 from sdcvalidator import SDC4Validator, ErrorTier
 
-# Validate an XML instance
+# Validate an XML instance (strict mode by default)
 validator = SDC4Validator("my_schema.xsd")
 result = validator.validate("my_instance.xml")
 
@@ -66,6 +67,19 @@ else:
         print(f"SEMANTIC: {err.reason}")
 ```
 
+### Validation modes
+
+The `validation` parameter controls how strictly the XSD schema itself is checked when loaded:
+
+- **`'strict'`** (default) — Raises `XMLSchemaParseError` if the schema contains invalid restriction derivations (e.g., element names that don't match the base type). This is the recommended mode.
+- **`'lax'`** — Silently collects schema derivation errors without raising. Use only for pre-existing schemas known to have issues.
+- **`'skip'`** — Skips schema-level validation entirely.
+
+```python
+# Explicit lax mode for legacy schemas
+validator = SDC4Validator("legacy_schema.xsd", validation='lax')
+```
+
 ### Schema compliance checking
 
 ```python

{sdcvalidator-4.1.0 → sdcvalidator-4.2.1}/src/sdcvalidator.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ src/sdcvalidator/cli.py
 src/sdcvalidator/constants.py
 src/sdcvalidator/converters.py
 src/sdcvalidator/error_classifier.py
+src/sdcvalidator/mcp_server.py
 src/sdcvalidator/schema_checker.py
 src/sdcvalidator/validator.py
 src/sdcvalidator.egg-info/PKG-INFO
@@ -16,5 +17,6 @@ src/sdcvalidator.egg-info/requires.txt
 src/sdcvalidator.egg-info/top_level.txt
 tests/test_converters.py
 tests/test_error_classifier.py
+tests/test_mcp_server.py
 tests/test_schema_checker.py
 tests/test_validator.py

{sdcvalidator-4.1.0 → sdcvalidator-4.2.1}/src/sdcvalidator.egg-info/entry_points.txt

@@ -1,4 +1,5 @@
 [console_scripts]
 sdcvalidate = sdcvalidator.cli:validate_main
 sdcvalidator-json2xml = sdcvalidator.cli:json2xml_main
+sdcvalidator-mcp = sdcvalidator.mcp_server:main
 sdcvalidator-xml2json = sdcvalidator.cli:xml2json_main

sdcvalidator-4.2.1/tests/test_mcp_server.py

@@ -0,0 +1,139 @@
+#
+# Copyright 2026 Semantic Data Charter Foundation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+"""
+Tests for MCP server - JSON-RPC 2.0 protocol and tool definitions.
+"""
+
+import json
+import pytest
+from pathlib import Path
+from sdcvalidator.mcp_server import _handle_request, TOOLS, TOOL_HANDLERS
+
+TEST_DATA_DIR = Path(__file__).parent / "test_data"
+
+
+def call_tool(name: str, arguments: dict) -> dict:
+    """Helper: call an MCP tool via JSON-RPC and return parsed result."""
+    request = {
+        "jsonrpc": "2.0",
+        "id": 1,
+        "method": "tools/call",
+        "params": {"name": name, "arguments": arguments},
+    }
+    response = _handle_request(request)
+    assert "result" in response, f"Expected result, got: {response}"
+    content = response["result"]["content"]
+    assert len(content) == 1
+    assert content[0]["type"] == "text"
+    return json.loads(content[0]["text"])
+
+
+class TestMcpProtocol:
+    """JSON-RPC 2.0 MCP protocol handling."""
+
+    def test_initialize(self):
+        request = {"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": {}}
+        response = _handle_request(request)
+        assert response["id"] == 1
+        result = response["result"]
+        assert result["serverInfo"]["name"] == "sdcvalidator"
+        assert "tools" in result["capabilities"]
+
+    def test_initialized_notification(self):
+        request = {"jsonrpc": "2.0", "method": "notifications/initialized"}
+        response = _handle_request(request)
+        assert response is None
+
+    def test_tools_list(self):
+        request = {"jsonrpc": "2.0", "id": 2, "method": "tools/list", "params": {}}
+        response = _handle_request(request)
+        tools = response["result"]["tools"]
+        assert len(tools) == 3
+        names = {t["name"] for t in tools}
+        assert names == {"validate_instance", "validate_and_report", "check_schema_compliance"}
+
+    def test_tools_have_input_schemas(self):
+        request = {"jsonrpc": "2.0", "id": 3, "method": "tools/list", "params": {}}
+        response = _handle_request(request)
+        for tool in response["result"]["tools"]:
+            assert "inputSchema" in tool
+            assert tool["inputSchema"]["type"] == "object"
+
+    def test_ping(self):
+        request = {"jsonrpc": "2.0", "id": 4, "method": "ping", "params": {}}
+        response = _handle_request(request)
+        assert response["id"] == 4
+        assert response["result"] == {}
+
+    def test_unknown_method(self):
+        request = {"jsonrpc": "2.0", "id": 5, "method": "nonexistent", "params": {}}
+        response = _handle_request(request)
+        assert "error" in response
+        assert response["error"]["code"] == -32601
+
+    def test_unknown_tool(self):
+        request = {
+            "jsonrpc": "2.0", "id": 6,
+            "method": "tools/call",
+            "params": {"name": "nonexistent_tool", "arguments": {}},
+        }
+        response = _handle_request(request)
+        assert "error" in response
+        assert "Unknown tool" in response["error"]["message"]
+
+
+class TestCheckSchemaCompliance:
+    """check_schema_compliance MCP tool."""
+
+    def test_valid_schema(self):
+        data = call_tool("check_schema_compliance", {
+            "schema_path": str(TEST_DATA_DIR / "valid_sdc4_schema.xsd"),
+        })
+        assert data["compliant"] is True
+        assert data["errors"] == []
+
+    def test_invalid_schema_with_extension(self):
+        data = call_tool("check_schema_compliance", {
+            "schema_path": str(TEST_DATA_DIR / "invalid_sdc4_schema_with_extension.xsd"),
+        })
+        assert data["compliant"] is False
+        assert len(data["errors"]) > 0
+        assert any("extension" in e.lower() for e in data["errors"])
+
+    def test_non_sdc4_schema_passes(self):
+        data = call_tool("check_schema_compliance", {
+            "schema_path": str(TEST_DATA_DIR / "non_sdc4_schema_with_extension.xsd"),
+        })
+        assert data["compliant"] is True
+
+    def test_nonexistent_file(self):
+        data = call_tool("check_schema_compliance", {
+            "schema_path": "/nonexistent/path/schema.xsd",
+        })
+        assert data["compliant"] is False
+        assert any("not found" in e.lower() for e in data["errors"])
+
+
+class TestConsistentSerialization:
+    """Verify all tools return consistent JSON-RPC format."""
+
+    def test_all_tools_return_single_text_content(self):
+        """Every tool returns exactly one content block with type=text."""
+        test_calls = [
+            ("check_schema_compliance", {"schema_path": str(TEST_DATA_DIR / "valid_sdc4_schema.xsd")}),
+        ]
+        for tool_name, args in test_calls:
+            request = {
+                "jsonrpc": "2.0", "id": 1,
+                "method": "tools/call",
+                "params": {"name": tool_name, "arguments": args},
+            }
+            response = _handle_request(request)
+            assert "result" in response, f"{tool_name} returned error: {response}"
+            content = response["result"]["content"]
+            assert len(content) == 1, f"{tool_name} returned {len(content)} content blocks"
+            assert content[0]["type"] == "text"
+            parsed = json.loads(content[0]["text"])
+            assert parsed is not None

{sdcvalidator-4.1.0 → sdcvalidator-4.2.1}/tests/test_validator.py

@@ -45,7 +45,9 @@ class TestSDC4Validator(unittest.TestCase):
             xml_path = Path(f.name)
 
         try:
-            validator = SDC4Validator(self.schema_path)
+            # Use lax for this pre-existing fixture (has restriction derivation
+            # issues under strict mode that are unrelated to this test's purpose)
+            validator = SDC4Validator(self.schema_path, validation='lax')
             result = validator.validate(xml_path)
 
             self.assertFalse(result.is_valid)
@@ -68,7 +70,7 @@ class TestSDC4Validator(unittest.TestCase):
             xml_path = Path(f.name)
 
         try:
-            validator = SDC4Validator(self.schema_path)
+            validator = SDC4Validator(self.schema_path, validation='lax')
             result = validator.validate(xml_path)
 
             self.assertFalse(result.is_valid)
@@ -110,7 +112,7 @@ class TestSDC4Validator(unittest.TestCase):
             xml_path = Path(f.name)
 
         try:
-            validator = SDC4Validator(self.schema_path)
+            validator = SDC4Validator(self.schema_path, validation='lax')
             result = validator.validate(xml_path)
 
             self.assertFalse(result.is_valid)
@@ -136,7 +138,7 @@ class TestSDC4Validator(unittest.TestCase):
             xml_path = Path(f.name)
 
         try:
-            validator = SDC4Validator(self.schema_path)
+            validator = SDC4Validator(self.schema_path, validation='lax')
             structural_errors = validator.validate_structure(xml_path)
             self.assertGreater(len(structural_errors), 0)
         finally:
@@ -160,7 +162,7 @@ class TestSDC4Validator(unittest.TestCase):
             xml_path = Path(f.name)
 
         try:
-            validator = SDC4Validator(self.schema_path)
+            validator = SDC4Validator(self.schema_path, validation='lax')
             structural_errors = validator.validate_structure(xml_path)
             self.assertEqual(len(structural_errors), 0)
         finally:
@@ -182,7 +184,7 @@ class TestSDC4Validator(unittest.TestCase):
             xml_path = Path(f.name)
 
         try:
-            validator = SDC4Validator(self.schema_path)
+            validator = SDC4Validator(self.schema_path, validation='lax')
             report = validator.validate_and_report(xml_path)
 
             self.assertFalse(report['valid'])
@@ -207,5 +209,149 @@ class TestSDC4Validator(unittest.TestCase):
         self.assertEqual(result2.error_count, 3)
 
 
+class TestStrictModeDefault(unittest.TestCase):
+    """Tests that strict mode is the default and catches invalid restrictions."""
+
+    def test_default_validation_is_strict(self):
+        """SDC4Validator defaults to validation='strict'."""
+        # valid_sdc4_schema.xsd is self-contained (no sdc4.xsd include)
+        # and has correct restriction derivation — should load fine in strict mode
+        schema_path = Path(__file__).parent / 'test_data' / 'valid_sdc4_schema.xsd'
+        validator = SDC4Validator(schema_path)
+        assert validator is not None
+        assert validator.schema is not None
+
+    def test_strict_mode_catches_invalid_restriction(self):
+        """Strict mode rejects schemas with invalid restriction derivations."""
+        # A schema where the restriction's element sequence doesn't match
+        # the base type — strict mode should raise during schema loading
+        bad_schema = '''\
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+            xmlns:sdc4="https://semanticdatacharter.com/ns/sdc4/"
+            targetNamespace="https://semanticdatacharter.com/ns/sdc4/"
+            elementFormDefault="qualified">
+
+    <xsd:complexType name="BaseType">
+        <xsd:sequence>
+            <xsd:element name="label" type="xsd:string"/>
+            <xsd:element name="value" type="xsd:string"/>
+        </xsd:sequence>
+    </xsd:complexType>
+
+    <xsd:complexType name="BadRestriction">
+        <xsd:complexContent>
+            <xsd:restriction base="sdc4:BaseType">
+                <xsd:sequence>
+                    <xsd:element name="label" type="xsd:string"/>
+                    <xsd:element name="wrong-name" type="xsd:string"/>
+                </xsd:sequence>
+            </xsd:restriction>
+        </xsd:complexContent>
+    </xsd:complexType>
+
+</xsd:schema>
+'''
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.xsd', delete=False) as f:
+            f.write(bad_schema)
+            schema_path = Path(f.name)
+
+        try:
+            from xmlschema.validators.exceptions import XMLSchemaParseError
+            with self.assertRaises(XMLSchemaParseError):
+                SDC4Validator(schema_path, check_sdc4_compliance=False, validation='strict')
+        finally:
+            schema_path.unlink()
+
+    def test_lax_mode_silently_accepts_invalid_restriction(self):
+        """Lax mode silently accepts the same invalid restriction (demonstrating the bug)."""
+        bad_schema = '''\
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+            xmlns:sdc4="https://semanticdatacharter.com/ns/sdc4/"
+            targetNamespace="https://semanticdatacharter.com/ns/sdc4/"
+            elementFormDefault="qualified">
+
+    <xsd:complexType name="BaseType">
+        <xsd:sequence>
+            <xsd:element name="label" type="xsd:string"/>
+            <xsd:element name="value" type="xsd:string"/>
+        </xsd:sequence>
+    </xsd:complexType>
+
+    <xsd:complexType name="BadRestriction">
+        <xsd:complexContent>
+            <xsd:restriction base="sdc4:BaseType">
+                <xsd:sequence>
+                    <xsd:element name="label" type="xsd:string"/>
+                    <xsd:element name="wrong-name" type="xsd:string"/>
+                </xsd:sequence>
+            </xsd:restriction>
+        </xsd:complexContent>
+    </xsd:complexType>
+
+</xsd:schema>
+'''
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.xsd', delete=False) as f:
+            f.write(bad_schema)
+            schema_path = Path(f.name)
+
+        try:
+            # Lax mode accepts this — which is the bug strict mode fixes
+            validator = SDC4Validator(
+                schema_path, check_sdc4_compliance=False, validation='lax'
+            )
+            self.assertIsNotNone(validator)
+        finally:
+            schema_path.unlink()
+
+    def test_valid_restriction_passes_strict(self):
+        """A correct restriction passes strict mode validation."""
+        good_schema = '''\
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+            xmlns:sdc4="https://semanticdatacharter.com/ns/sdc4/"
+            targetNamespace="https://semanticdatacharter.com/ns/sdc4/"
+            elementFormDefault="qualified">
+
+    <xsd:complexType name="BaseType">
+        <xsd:sequence>
+            <xsd:element name="label" type="xsd:string"/>
+            <xsd:element name="value" type="xsd:string"/>
+        </xsd:sequence>
+    </xsd:complexType>
+
+    <xsd:complexType name="GoodRestriction">
+        <xsd:complexContent>
+            <xsd:restriction base="sdc4:BaseType">
+                <xsd:sequence>
+                    <xsd:element name="label" type="xsd:string" fixed="Test"/>
+                    <xsd:element name="value">
+                        <xsd:simpleType>
+                            <xsd:restriction base="xsd:string">
+                                <xsd:maxLength value="100"/>
+                            </xsd:restriction>
+                        </xsd:simpleType>
+                    </xsd:element>
+                </xsd:sequence>
+            </xsd:restriction>
+        </xsd:complexContent>
+    </xsd:complexType>
+
+</xsd:schema>
+'''
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.xsd', delete=False) as f:
+            f.write(good_schema)
+            schema_path = Path(f.name)
+
+        try:
+            validator = SDC4Validator(
+                schema_path, check_sdc4_compliance=False, validation='strict'
+            )
+            self.assertIsNotNone(validator)
+        finally:
+            schema_path.unlink()
+
+
 if __name__ == '__main__':
     unittest.main()