quantum-framework 0.11.0__tar.gz → 0.12.0__tar.gz

{quantum_framework-0.11.0/quantum_framework.egg-info → quantum_framework-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quantum-framework
-Version: 0.11.0
+Version: 0.12.0
 Summary: Full-stack declarative framework for building web, desktop, and mobile applications
 Author-email: Daniel Gregorio <danielgregorio2611@gmail.com>
 License: MIT
@@ -37,6 +37,10 @@ Provides-Extra: rag
 Requires-Dist: chromadb>=0.5.0; extra == "rag"
 Provides-Extra: jobs
 Requires-Dist: apscheduler>=3.10.0; extra == "jobs"
+Provides-Extra: admin
+Requires-Dist: sqlalchemy>=2.0; extra == "admin"
+Requires-Dist: PyJWT>=2.8; extra == "admin"
+Requires-Dist: cryptography>=42.0; extra == "admin"
 Provides-Extra: websocket
 Requires-Dist: websockets>=12.0; extra == "websocket"
 Dynamic: license-file

{quantum_framework-0.11.0 → quantum_framework-0.12.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "quantum-framework"
-version = "0.11.0"
+version = "0.12.0"
 description = "Full-stack declarative framework for building web, desktop, and mobile applications"
 readme = "README.md"
 license = {text = "MIT"}
@@ -50,6 +50,13 @@ jobs = [
     # q:schedule failed on any clean install.
     "apscheduler>=3.10.0",
 ]
+admin = [
+    # `quantum admin`: the admin database (SQLAlchemy), its login tokens
+    # (PyJWT) and encrypted connector secrets (cryptography).
+    "sqlalchemy>=2.0",
+    "PyJWT>=2.8",
+    "cryptography>=42.0",
+]
 websocket = [
     # The transport behind q:websocket. Without it the tag registers a
     # connection and opens nothing — and says so, rather than pretending.
@@ -71,7 +78,14 @@ Repository = "https://github.com/danielgregorio/quantum"
 # do core), e as pastas `quantum-as4`/`quantum-lsp` (projetos irmaos,
 # hifenados e nem importaveis) — 91 arquivos de peso morto no wheel. O ponto
 # em `quantum.*` casa subpacotes; sem ele, `quantum_admin` nao entra.
-include = ["quantum", "quantum.*"]
+include = ["quantum", "quantum.*",
+           # The admin (`quantum admin`, extra [admin]): its screens, its
+           # services and the backend library they use. The backend's
+           # FastAPI modules ship with it, unused by the screens.
+           "quantum_admin", "quantum_admin.services", "quantum_admin.backend"]
+
+[tool.setuptools.package-data]
+quantum_admin = ["components/**/*.q", "assets/*"]
 
 
 [tool.black]

quantum_framework-0.12.0/quantum/cli/admin.py

@@ -0,0 +1,131 @@
+"""`quantum admin` — serve the Quantum Admin (quantum_admin/components/admin).
+
+The admin is a Quantum app: .q screens over declared services. This command
+writes its configuration into a data folder and starts the same server as
+`quantum start`, so nothing has to be set up by hand.
+
+    quantum admin                      # data in ./.quantum-admin, projects under ./
+    quantum admin --data quantum_admin # the repository's own admin data
+
+The data folder holds the admin database, its settings (connectors, global
+settings, process PIDs) and the generated config. Paths of projects are
+relative to the folder the command runs in (--root to change it).
+"""
+
+import os
+import secrets
+from pathlib import Path
+
+MODULES = [
+    "quantum_admin.services.auth",
+    "quantum_admin.services.projects",
+    "quantum_admin.services.yaml_import",
+    "quantum_admin.services.connectors",
+    "quantum_admin.services.settings",
+    "quantum_admin.services.components",
+    "quantum_admin.services.apps",
+    "quantum_admin.services.repository",
+]
+
+INSTALL_HINT = 'pip install "quantum-framework[admin]"'
+
+
+def create_admin_parser(subparsers):
+    parser = subparsers.add_parser('admin', help='Start the Quantum Admin')
+    parser.add_argument('--port', type=int, default=8090, help='Port (default 8090)')
+    parser.add_argument('--data', default='.quantum-admin',
+                        help='Folder for the admin database and settings (default ./.quantum-admin)')
+    parser.add_argument('--root', default='.',
+                        help='Folder the project paths are relative to (default: current folder)')
+    return parser
+
+
+def missing_dependencies():
+    """Names of the [admin] extra's packages that do not import."""
+    faltando = []
+    for modulo, pacote in (("sqlalchemy", "SQLAlchemy"), ("jwt", "PyJWT"),
+                           ("cryptography", "cryptography")):
+        try:
+            __import__(modulo)
+        except ImportError:
+            faltando.append(pacote)
+    return faltando
+
+
+def _package() -> Path:
+    import quantum_admin
+    return Path(quantum_admin.__file__).resolve().parent
+
+
+def screens_folder() -> Path:
+    return _package() / "components"
+
+
+def assets_folder() -> Path:
+    """The screens' CSS and JS, served under /static/."""
+    return _package() / "assets"
+
+
+def _secret(arquivo: Path) -> str:
+    """A key kept in the data folder, so sessions survive a restart."""
+    if arquivo.exists():
+        return arquivo.read_text(encoding="utf-8").strip()
+    chave = secrets.token_hex(32)
+    arquivo.write_text(chave, encoding="utf-8")
+    try:
+        arquivo.chmod(0o600)
+    except OSError:
+        pass
+    return chave
+
+
+def prepare(data: str, root: str, port: int) -> Path:
+    """Create the data folder, point the admin at it, write the config. Returns its path."""
+    import yaml
+
+    pasta = Path(data).resolve()
+    (pasta / "settings").mkdir(parents=True, exist_ok=True)
+
+    # Read by quantum_admin.backend at import time, so set before any import.
+    os.environ["QUANTUM_ADMIN_DATABASE_URL"] = f"sqlite:///{(pasta / 'quantum_admin.db').as_posix()}"
+    os.environ["QUANTUM_ADMIN_SETTINGS_DIR"] = str(pasta / "settings")
+    os.environ["QUANTUM_ADMIN_ROOT"] = str(Path(root).resolve())
+    os.environ.setdefault("JWT_SECRET_KEY", _secret(pasta / "jwt_secret"))
+
+    config = pasta / "quantum.config.yaml"
+    config.write_text(
+        "# Generated by `quantum admin` on every start; edits are overwritten.\n" +
+        yaml.safe_dump({
+            "server": {"host": "127.0.0.1", "port": port, "reload": False, "debug": False},
+            "paths": {"components": screens_folder().as_posix(),
+                      "static": assets_folder().as_posix(),
+                      "uploads": (pasta / "uploads").as_posix(),
+                      "logs": (pasta / "logs").as_posix()},
+            "security": {"login_url": "/admin/login", "secret_key": _secret(pasta / "session_secret")},
+            "logging": {"level": "WARNING", "console": True, "file": False},
+            "services": MODULES,
+        }, sort_keys=False),
+        encoding="utf-8")
+    return config
+
+
+def handle_admin(args) -> int:
+    faltando = missing_dependencies()
+    if faltando:
+        print(f"[ERROR] The admin needs {', '.join(faltando)}. Install with:\n  {INSTALL_HINT}")
+        return 1
+
+    config = prepare(args.data, args.root, args.port)
+
+    from quantum.runtime.web_server import QuantumWebServer
+    from quantum_admin.backend.auth_service import get_auth_service
+
+    # Created now, not at the first login, so a generated password is printed
+    # before the URL instead of in the middle of the request log.
+    get_auth_service()
+    print(f"\n  Quantum Admin: http://127.0.0.1:{args.port}/admin"
+          f"\n  data: {config.parent}\n")
+
+    server = QuantumWebServer(str(config))
+    server.PID_FILE = str(config.parent / "admin.pid")
+    return server.start() or 0

{quantum_framework-0.11.0 → quantum_framework-0.12.0}/quantum/cli/runner.py

@@ -280,6 +280,7 @@ def main():
 Examples:
   quantum start                    # Start web server (magic!)
   quantum run hello.q              # Execute component
+  quantum admin                    # Start the Quantum Admin
   quantum run game.q --engine godot # Build Godot 4 project
   quantum run backup-job.q         # Execute job
   quantum deploy ./my-app          # Deploy application
@@ -330,6 +331,10 @@ Examples:
     # Stop command
     subparsers.add_parser('stop', help='Stop running web server')
 
+    # Admin command (the screens need the [admin] extra; checked when run)
+    from quantum.cli.admin import create_admin_parser
+    create_admin_parser(subparsers)
+
     # Deploy commands (if available)
     deploy_available, create_deploy_parser, create_apps_parser, handle_deploy, handle_apps = _get_deploy_module()
 
@@ -392,6 +397,10 @@ Examples:
                 traceback.print_exc()
             sys.exit(1)
 
+    elif args.command == 'admin':
+        from quantum.cli.admin import handle_admin
+        sys.exit(handle_admin(args))
+
     # Handle 'stop' command
     elif args.command == 'stop':
         from quantum.cli.server_process import stop_server

{quantum_framework-0.11.0 → quantum_framework-0.12.0}/quantum/core/ast_nodes.py

@@ -112,6 +112,7 @@ class ComponentNode(QuantumNode):
         # Phase G: Authentication & Security
         self.require_auth = False  # Require authentication to access component
         self.require_role = None   # Required role(s) to access (comma-separated: "admin,editor")
+        self.login_url = None      # AUTH-4: overrides security.login_url for this component
         self.require_permission = None  # Required permission(s)
 
         # HTML rendering & interactivity (Phase 1 & future Phase 3)

{quantum_framework-0.11.0 → quantum_framework-0.12.0}/quantum/core/expressions.py

@@ -423,18 +423,18 @@ class ExpressionEvaluator:
             return op(operand)
 
         if isinstance(node, ast.BoolOp):
-            values = [self._eval(v, ctx) for v in node.values]
-            if isinstance(node.op, ast.And):
-                result = True
-                for v in values:
-                    if not v:
-                        return v
-                    result = v
-                return result
-            for v in values:
-                if v:
-                    return v
-            return values[-1] if values else False
+            # EXPR-6: short-circuit, as in Python. Every operand used to be
+            # evaluated first, so `user and user.name` failed with "variable
+            # 'user' is not defined"-style errors exactly when the left side
+            # was there to guard the right.
+            valor = False
+            for operando in node.values:
+                valor = self._eval(operando, ctx)
+                if isinstance(node.op, ast.And) and not valor:
+                    return valor
+                if isinstance(node.op, ast.Or) and valor:
+                    return valor
+            return valor
 
         if isinstance(node, ast.Compare):
             left = self._eval(node.left, ctx)

{quantum_framework-0.11.0 → quantum_framework-0.12.0}/quantum/core/parser.py

@@ -584,6 +584,13 @@ class QuantumParser:
         require_auth_attr = root.get('require_auth', 'false').lower()
         component.require_auth = require_auth_attr in ['true', '1', 'yes']
         component.require_role = root.get('require_role')
+        # AUTH-4: where this component sends a visitor without a session.
+        component.login_url = root.get('login_url')
+        if component.login_url is not None and (not component.login_url.startswith('/')
+                                                or component.login_url.startswith('//')):
+            raise QuantumParseError(
+                f'<q:component name="{component.name}"> login_url must be a path on this server, '
+                f'like /login; got {component.login_url!r}')
         component.require_permission = root.get('require_permission')
 
         # HTML rendering & interactivity (Phase 1 & future Phase 3)
@@ -618,7 +625,108 @@ class QuantumParser:
         # Parse control flow statements (if, loop, set, dispatchEvent, etc)
         self._parse_control_flow_statements(root, component)
 
+        self._check_statements_in_markup(component)
+
         return component
+
+    # Nodes the HTML renderer draws. Anything else inside markup is a statement,
+    # and statements run in the execution pass, before the render pass sees
+    # the markup around them.
+    _RENDERED = (HTMLNode, TextNode, CommentNode, DocTypeNode, LoopNode, IfNode,
+                 ComponentCallNode, SlotNode, ImportNode)
+
+    def _check_statements_in_markup(self, component: ComponentNode) -> None:
+        """PARSE-2: a statement where it would never run, or run with the wrong values.
+
+        Execution walks the component's statements and skips markup; the
+        renderer walks the markup and skips statements. So a q:set inside a
+        <ul> never ran — `<li>{y}</li>` printed the literal `{y}` — and a q:set
+        in a q:loop that also renders rows ran once per row in the execution
+        pass, leaving every row to render with the LAST value. Both were
+        silent.
+        """
+        def filhos(node):
+            if isinstance(node, IfNode):
+                corpo = list(node.if_body)
+                for bloco in node.elseif_blocks:
+                    corpo += list(bloco.get('body', []))
+                return corpo + list(node.else_body)
+            if isinstance(node, LoopNode):
+                return list(node.body)
+            if isinstance(node, (HTMLNode, ComponentCallNode)):
+                return list(node.children or [])
+            return []
+
+        def renderiza(nodes):
+            for node in nodes:
+                if isinstance(node, TextNode):
+                    if node.content.strip():
+                        return True
+                elif isinstance(node, (HTMLNode, ComponentCallNode)):
+                    return True
+                elif isinstance(node, (IfNode, LoopNode)) and renderiza(filhos(node)):
+                    return True
+            return False
+
+        def tag(node):
+            nome = type(node).__name__
+            nome = nome[:-4] if nome.endswith('Node') else nome
+            rotulo = f"q:{nome[:1].lower()}{nome[1:]}"
+            atributo = getattr(node, 'name', None)
+            return f'<{rotulo} name="{atributo}">' if isinstance(atributo, str) else f'<{rotulo}>'
+
+        def expressoes(nodes):
+            """The text the renderer evaluates under `nodes`: contents, attributes, conditions."""
+            partes = []
+            for node in nodes:
+                if isinstance(node, TextNode):
+                    partes.append(node.content)
+                elif isinstance(node, HTMLNode):
+                    partes.extend(str(v) for v in (node.attributes or {}).values())
+                elif isinstance(node, ComponentCallNode):
+                    partes.extend(str(v) for v in (node.props or {}).values())
+                elif isinstance(node, IfNode):
+                    partes.append('{%s}' % node.condition)
+                    partes.extend('{%s}' % b.get('condition', '') for b in node.elseif_blocks)
+                elif isinstance(node, LoopNode):
+                    partes.append('{%s}' % (node.items or ''))
+                partes.append(expressoes(filhos(node)))
+            return '\n'.join(partes)
+
+        def usado(nome, texto):
+            padrao = re.compile(r'(?<![\w.])' + re.escape(nome) + r'(?![\w])')
+            return any(padrao.search(m) for m in re.findall(r'\{([^{}]*)\}', texto))
+
+        def andar(nodes, onde):
+            for node in nodes:
+                if not isinstance(node, self._RENDERED):
+                    if onde and onde[0] == 'markup':
+                        raise QuantumParseError(
+                            f'{tag(node)} inside {onde[1]} in <q:component name="{component.name}"> '
+                            f'never runs: statements run before the page is rendered, and markup '
+                            f'is only rendered. Move it above the markup (or into a q:action).')
+                    nome = getattr(node, 'name', None)
+                    # A running total read AFTER the loop is fine; a value the
+                    # loop's own rows read is not.
+                    if onde and isinstance(nome, str) and usado(nome, onde[1]):
+                        raise QuantumParseError(
+                            f'{tag(node)} inside a q:loop whose rows use {{{nome}}} in '
+                            f'<q:component name="{component.name}">: the loop runs for every item '
+                            f'before any row is rendered, so every row would show the last value. '
+                            f'Compute it in the expression instead, e.g. {{item.price * item.qty}}.')
+                    continue
+                if isinstance(node, HTMLNode):
+                    andar(filhos(node), onde if onde and onde[0] == 'markup' else ('markup', f'<{node.tag}>'))
+                elif isinstance(node, ComponentCallNode):
+                    andar(filhos(node), onde if onde and onde[0] == 'markup'
+                          else ('markup', f'the content of <{node.component_name}>'))
+                elif isinstance(node, LoopNode):
+                    corpo = filhos(node)
+                    andar(corpo, onde or (('loop', expressoes(corpo)) if renderiza(corpo) else None))
+                elif isinstance(node, IfNode):
+                    andar(filhos(node), onde)
+
+        andar(component.statements, None)
     
     def _parse_control_flow_statements(self, parent: ET.Element, component: ComponentNode):
         """Parse control flow statements - delegates to modular parser registry"""

{quantum_framework-0.11.0 → quantum_framework-0.12.0}/quantum/core/parsers/data/invoke_parser.py

@@ -46,7 +46,10 @@ class InvokeParser(BaseTagParser):
         invoke_node.function = self.get_attr(element, 'function')
         invoke_node.component = self.get_attr(element, 'component')
         invoke_node.url = self.get_attr(element, 'url')
-        invoke_node.endpoint = self.get_attr(element, 'endpoint')
+        if self.get_attr(element, 'endpoint') is not None:
+            raise ParserError(
+                f'<q:invoke name="{name}"> endpoint= is not supported: it was accepted and never '
+                f'did anything, and was removed in Quantum 0.12. Use url= or service=.')
         invoke_node.service = self.get_attr(element, 'service')
 
         # HTTP attributes

{quantum_framework-0.11.0 → quantum_framework-0.12.0}/quantum/runtime/action_handler.py

@@ -46,7 +46,8 @@ class ActionHandler:
     def handle_action(
         self,
         action: ActionNode,
-        context: Optional[ExecutionContext] = None
+        context: Optional[ExecutionContext] = None,
+        route_params: Optional[Dict[str, str]] = None
     ) -> Tuple[Optional[str], int]:
         """
         Handle action execution.
@@ -97,6 +98,14 @@ class ActionHandler:
                 if key != 'files' and not param_validation.is_uploaded_file(value)
             })
 
+            # ROUTE-2: the page's route segments ([nome], [...caminho]) are
+            # variables of the action too, set last so a form field with the
+            # same name cannot replace them. A POST to /admin/app/loja used to
+            # run without `name`, so every form had to repeat it in a hidden
+            # field — one the browser can change.
+            for key, value in (route_params or {}).items():
+                context.set_variable(key, value)
+
             # 4. Execute action body
             redirect_info = self._execute_action_body(action, context)
 
@@ -419,18 +428,17 @@ class ActionHandler:
             context.set_variable(key, value, scope="component")
 
     def _resolve_databinding(self, text: str, context: ExecutionContext) -> str:
-        """Resolve {variable} databinding in text"""
+        """Resolve {expressions} in a redirect URL or flash message (ACT-3).
+
+        This looked each {name} up with get_variable, so anything but a plain
+        name failed — `flash="{result.error}"` or `{len(itens)} saved` ended
+        the action with "Variable 'result.error' not found in any scope" and a
+        500. It now goes through the same evaluator as every q: attribute.
+        """
         if not text or '{' not in text:
             return text
-
-        import re
-
-        def replace_var(match):
-            var_name = match.group(1)
-            value = context.get_variable(var_name)
-            return str(value) if value is not None else ''
-
-        return re.sub(r'\{([^}]+)\}', replace_var, text)
+        valor = self.component_runtime._apply_databinding(text, context.get_all_variables())
+        return '' if valor is None else str(valor)
 
     def _set_flash_message(self, message: str, flash_type: str = 'info'):
         """Set flash message in session"""

{quantum_framework-0.11.0 → quantum_framework-0.12.0}/quantum/runtime/component.py

@@ -455,10 +455,9 @@ class ComponentRuntime:
         # assembles code out of data. Same change as HTMLRenderer.
         stripped = self._databinding_pattern.sub(lambda m: m.group(1), condition).strip()
 
-        # A regex quantifier as a whole condition is meaningless; false.
-        if is_regex_quantifier(stripped):
-            return False
-
+        # IF-2: `1` and `{1}` are the number 1, true. There used to be a
+        # regex-quantifier check here that made every such condition false;
+        # a condition is never a regex, and HTMLRenderer never had the check.
         try:
             return bool(self._expressions.evaluate(stripped, context or {}))
         except UndefinedError:

quantum_framework-0.12.0/quantum/runtime/component_composer.py

@@ -0,0 +1,133 @@
+"""
+Quantum Component Composer — <Component prop="…">slot content</Component>.
+
+COMP-1..4 (SPEC.md). What this used to get wrong, found by building the admin
+layout on it:
+
+  - the component was searched in ./components relative to the process's
+    working directory — paths.components from quantum.config.yaml and the
+    `from=` of q:import were ignored;
+  - a component that was not found, or failed, became an HTML comment and the
+    page answered 200 with the section missing;
+  - the child ran as ComponentRuntime() with no configuration, so a q:query
+    or q:invoke service= inside a child component had no datasources/services;
+  - slot content was grafted into the child's AST and evaluated in the
+    CHILD's scope: a q:loop over the page's rows inside a layout saw nothing.
+    Worse, the graft mutated the child AST held in the resolver cache, so the
+    first request's slot content replaced the q:slot for every later request;
+  - props used get_variable only (no expressions) and fell back to the
+    placeholder text on failure.
+"""
+
+import re
+from typing import Any, Dict, List
+
+from quantum.core.ast_nodes import ComponentCallNode, ComponentNode, HTMLNode, QuantumNode, SlotNode
+from quantum.core.expressions import ExpressionError
+from quantum.runtime.component import ComponentRuntime
+from quantum.runtime.component_resolver import ComponentNotFoundError, ComponentResolver
+
+
+class ComponentCompositionError(Exception):
+    """A component call could not be composed; the message names the component."""
+
+
+class RenderedHTML(QuantumNode):
+    """Markup the parent already rendered (slot content), inserted as-is."""
+
+    def __init__(self, html: str):
+        self.html = html
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {"type": "rendered_html", "length": len(self.html)}
+
+    def validate(self) -> List[str]:
+        return []
+
+
+class ComponentComposer:
+    def __init__(self, resolver: ComponentResolver):
+        self.resolver = resolver
+
+    def compose(self, call: ComponentCallNode, parent) -> str:
+        """Render `call` as a child of the HTMLRenderer `parent`."""
+        from quantum.runtime.renderer import HTMLRenderer
+
+        nome, origem = parent.imports.get(call.component_name, (call.component_name, None))
+        try:
+            child = self.resolver.resolve(nome, origem).ast
+        except ComponentNotFoundError as exc:
+            raise ComponentCompositionError(f"<{call.component_name}>: {exc}") from exc
+
+        props = self._props(child, call, parent)
+        # COMP-4: the same configuration and the same session, application and
+        # request scopes as the page — a layout showing {session.userName}
+        # used to see an empty session.
+        props.update(_session_scope=parent.context.session_vars,
+                     _application_scope=parent.context.application_vars,
+                     _request_scope=parent.context.request_vars)
+        runtime = ComponentRuntime(config=parent.config)
+        runtime.execute_component(child, props)
+
+        # COMP-3: slot content belongs to the page — rendered here, with the
+        # page's variables, before the child sees it.
+        slot = RenderedHTML(parent.render_all(call.children)) if call.children else None
+        preenchido = ComponentNode(name=child.name, component_type=child.component_type)
+        preenchido.statements = self._com_slot(child.statements, slot)
+        preenchido.params, preenchido.returns, preenchido.functions = child.params, child.returns, child.functions
+
+        renderer = HTMLRenderer(runtime.execution_context, components_dir=parent.components_dir,
+                                function_resolver=runtime._resolve_expression_function, config=parent.config)
+        return renderer.render(preenchido)
+
+    def _props(self, child: ComponentNode, call: ComponentCallNode, parent) -> Dict[str, Any]:
+        props = {}
+        for definicao in child.params:
+            if definicao.name in call.props:
+                props[definicao.name] = self._avaliar(call.props[definicao.name], definicao.name, call, parent)
+            elif definicao.default is not None:
+                props[definicao.name] = definicao.default
+            elif definicao.required:
+                raise ComponentCompositionError(
+                    f"<{call.component_name}> requires the prop {definicao.name!r}")
+        return props
+
+    @staticmethod
+    def _avaliar(valor, prop, call, parent):
+        """COMP-2: a prop is an attribute of a tag — an expression that fails is an error."""
+        if not isinstance(valor, str) or "{" not in valor:
+            return valor
+        variaveis = parent.context.get_all_variables()
+        try:
+            inteira = re.fullmatch(r"\s*\{([^{}]*)\}\s*", valor)
+            if inteira:
+                return parent._expressions.evaluate(inteira.group(1), variaveis)
+            return re.sub(r"\{([^{}]*)\}",
+                          lambda m: str(parent._expressions.evaluate(m.group(1), variaveis)), valor)
+        except ExpressionError as exc:
+            raise ComponentCompositionError(
+                f"<{call.component_name} {prop}=\"{valor}\">: {exc}") from exc
+
+    def _com_slot(self, nodes: List[QuantumNode], slot) -> List[QuantumNode]:
+        """Copy of `nodes` with each q:slot replaced — the cached child AST is never touched."""
+        resultado = []
+        for node in nodes:
+            if isinstance(node, SlotNode):
+                # Only the default slot receives the call's children; named
+                # slots keep their default content (named slots are not
+                # implemented, as before).
+                if slot is not None and (node.name or "default") == "default":
+                    resultado.append(slot)
+                else:
+                    resultado.extend(node.default_content or [])
+            elif isinstance(node, HTMLNode) and self._tem_slot(node.children):
+                copia = HTMLNode(tag=node.tag, attributes=dict(node.attributes),
+                                 children=self._com_slot(node.children, slot), self_closing=node.self_closing)
+                resultado.append(copia)
+            else:
+                resultado.append(node)
+        return resultado
+
+    def _tem_slot(self, nodes) -> bool:
+        return any(isinstance(n, SlotNode) or (isinstance(n, HTMLNode) and self._tem_slot(n.children))
+                   for n in nodes)