continuo-python-runtime 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

continuo_python_runtime/contract/loader.py

@@ -11,6 +11,9 @@ from pathlib import Path
 from typing import Any
 
 import yaml
+from continuo_validation_contract.sql import ensure_single_read  # type: ignore[import-untyped]
+from sqlglot import Dialect
+from sqlglot.errors import TokenError
 
 from continuo_python_runtime.contract.model import (
     CRITICALITIES,
@@ -32,6 +35,7 @@ _ALLOWED_KEYS = {
     "extra_columns",
     "reads",
     "output_columns",
+    "config",
     "content_hash",
 }
 
@@ -40,129 +44,6 @@ _REQUIRED_STRING_FIELDS = ("schema", "table", "owner", "schedule", "script")
 _ALLOWED_OUTPUT_COLUMN_KEYS = {"name", "type", "nullable"}
 
 
-def _mask_string_literals(sql: str) -> str | None:
-    """Return ``sql`` with the contents of single/double-quoted string
-    literals removed, so a ``;`` scan doesn't trip on one embedded in a
-    literal (e.g. ``split_part(tags, ';', 1)``).
-
-    Handles doubled ``''`` escapes inside single-quoted strings. The quote
-    delimiters themselves are kept; only the interior characters are
-    dropped. The result is not valid SQL - it exists solely for the
-    semicolon check below.
-
-    Returns ``None`` if a single- or double-quoted literal is left
-    unterminated (no closing quote before the end of the string): silently
-    truncating in that case would drop everything after the opening quote
-    -- including any ``;`` it was hiding -- and let a multi-statement read
-    through undetected.
-    """
-    result = []
-    i = 0
-    n = len(sql)
-    while i < n:
-        ch = sql[i]
-        if ch == "'":
-            result.append(ch)
-            i += 1
-            closed = False
-            while i < n:
-                if sql[i] == "'":
-                    if i + 1 < n and sql[i + 1] == "'":
-                        # doubled '' escape: part of the literal, drop both
-                        i += 2
-                        continue
-                    result.append(sql[i])
-                    i += 1
-                    closed = True
-                    break
-                i += 1
-            if not closed:
-                return None
-            continue
-        if ch == '"':
-            result.append(ch)
-            i += 1
-            closed = False
-            while i < n:
-                if sql[i] == '"':
-                    result.append(sql[i])
-                    i += 1
-                    closed = True
-                    break
-                i += 1
-            if not closed:
-                return None
-            continue
-        result.append(ch)
-        i += 1
-    return "".join(result)
-
-
-def _strip_leading_sql_comments(sql: str) -> str:
-    """Strip leading whitespace, ``-- ...`` line comments, and ``/* ... */``
-    block comments from the start of ``sql``.
-
-    An unterminated ``/*`` block comment (no closing ``*/``) consumes the
-    rest of the string, so callers see an empty statement rather than a
-    crash. Bounded by ``len(sql) + 1`` iterations (each iteration strictly
-    shrinks ``text``) with an explicit trailing return, so every path
-    returns a definite ``str`` rather than relying on an unbounded
-    ``while True`` loop that a type checker can't prove always exits via
-    ``return``.
-    """
-    text = sql
-    for _ in range(len(sql) + 1):
-        stripped = text.lstrip()
-        if stripped.startswith("--"):
-            newline = stripped.find("\n")
-            text = stripped[newline + 1 :] if newline != -1 else ""
-            continue
-        if stripped.startswith("/*"):
-            end = stripped.find("*/")
-            text = stripped[end + 2 :] if end != -1 else ""
-            continue
-        return stripped
-    return text.lstrip()
-
-
-def _validate_read_shape(label: str, name: str, sql: str) -> None:
-    """Enforce the §13.1 read shape: a single SELECT/WITH statement.
-
-    The read, after stripping whitespace and leading SQL comments, must
-    start with ``select``, ``with``, or a leading ``(`` (a parenthesized
-    SELECT), case-insensitive. It must contain no ``;`` except one optional
-    trailing semicolon; the semicolon scan is literal-aware, ignoring ``;``
-    characters inside single/double-quoted string literals. An unterminated
-    string literal is itself rejected -- it can otherwise hide arbitrary
-    trailing SQL (including a ``;``) from the scan.
-    Schema-qualification is left to the control plane's sqlglot validation.
-
-    Raises:
-        ContractError: If the shape is violated, naming the read.
-    """
-    stripped = sql.strip()
-    body = stripped[:-1] if stripped.endswith(";") else stripped
-    masked = _mask_string_literals(body)
-    if masked is None:
-        raise ContractError(
-            f"{label}: read '{name}' has an unterminated string literal"
-        )
-    if ";" in masked:
-        raise ContractError(
-            f"{label}: 'reads.{name}' must be a single SQL statement "
-            f"(only one optional trailing semicolon allowed)"
-        )
-    lowered = _strip_leading_sql_comments(body).lower()
-    if not (
-        lowered.startswith("select")
-        or lowered.startswith("with")
-        or lowered.startswith("(")
-    ):
-        raise ContractError(
-            f"{label}: 'reads.{name}' must start with SELECT or WITH"
-        )
-
-
 class _StrictLoader(yaml.SafeLoader):
     """SafeLoader that rejects duplicate mapping keys instead of keeping the last."""
 
@@ -193,10 +74,90 @@ def _node_label(raw: dict[str, Any], source: str) -> str:
     return source
 
 
-def parse_node(raw: dict[str, Any], source: str) -> Node:
+_JSON_SCALARS = (str, int, float, bool, type(None))
+
+
+def _validate_config(raw: Any, label: str) -> dict[str, Any]:
+    """Validate the node's physical-layout `config` as a JSON-shaped mapping.
+
+    The engine's adapter — not this loader — owns the vocabulary (§3.3), so the
+    only rules here are the ones the hash and the wire format need: it is a
+    mapping, every key at every level is a string, and every value is
+    JSON-serializable. Non-string keys would make `json.dumps(..., sort_keys=True)`
+    raise inside the hasher, and a non-serializable value would break the wire
+    artifact — both must surface here, naming the node, not deep in CI.
+
+    YAML aliases (``&anchor`` / ``*anchor``) can make PyYAML construct a
+    genuinely cyclic object graph — a mapping whose own value (however deeply
+    nested) is itself. Recursing into that without tracking what is already
+    on the call stack raises an uncaught ``RecursionError`` instead of this
+    function's promised ``ContractError``. ``active`` holds the ``id()`` of
+    every dict/list container currently being descended into; a container is
+    added just before recursing into its items and discarded right after, so
+    re-entering one still on the stack is a genuine back-edge (a cycle), while
+    the *same* container reached twice at sibling positions — a legal DAG,
+    e.g. one list aliased under two different keys — is not: its first visit
+    finishes (and is discarded) before the second begins.
+    """
+    if raw is None:
+        return {}
+    if not isinstance(raw, dict):
+        raise ContractError(f"{label}: 'config' must be a mapping")
+
+    active: set[int] = set()
+
+    def _check(value: Any, key: Any) -> None:
+        """Validate ``value`` (found under ``key`` in its enclosing mapping)."""
+        if isinstance(value, (dict, list)):
+            container_id = id(value)
+            if container_id in active:
+                raise ContractError(
+                    f"{label}: 'config' contains a circular reference at {key!r}"
+                )
+            active.add(container_id)
+            try:
+                if isinstance(value, dict):
+                    for sub_key, sub_value in value.items():
+                        if not isinstance(sub_key, str):
+                            raise ContractError(
+                                f"{label}: 'config' keys must be strings, got {sub_key!r}"
+                            )
+                        _check(sub_value, sub_key)
+                else:
+                    for item in value:
+                        _check(item, key)
+            finally:
+                active.discard(container_id)
+        elif not isinstance(value, _JSON_SCALARS):
+            raise ContractError(
+                f"{label}: 'config' value for {key!r} is not JSON-serializable: {value!r}"
+            )
+
+    _check(raw, None)
+    return raw
+
+
+def parse_node(
+    raw: dict[str, Any],
+    source: str,
+    *,
+    dialect: str | None = None,
+    check_reads: bool = True,
+) -> Node:
     """Validate a single raw mapping and build a :class:`Node`.
 
     ``source`` is the originating filename; it appears in every error message.
+    ``dialect`` is a sqlglot dialect name (e.g. ``"postgres"``, ``"trino"``)
+    each declared read is checked against via
+    :func:`~continuo_validation_contract.sql.ensure_single_read`; ``None``
+    (the default) uses sqlglot's dialect-neutral parser.
+
+    ``check_reads=False`` skips *only* that :func:`ensure_single_read` call —
+    the read-shape gate — leaving every other rule here (required fields,
+    criticality, the ``reads`` map's own shape, output-column types and
+    uniqueness, ``config``, ``content_hash``) in force. It exists for
+    :func:`~continuo_python_runtime.harness.run_node`; see
+    :func:`load_contract_dir` for why the runtime opts out.
     """
     if not isinstance(raw, dict):
         raise ContractError(
@@ -252,7 +213,26 @@ def parse_node(raw: dict[str, Any], source: str) -> Node:
             raise ContractError(
                 f"{label}: 'reads.{name}' must be a non-empty SQL string"
             )
-        _validate_read_shape(label, name, sql)
+        if not check_reads:
+            continue
+        try:
+            ensure_single_read(sql, dialect)
+        except (ValueError, TokenError) as exc:
+            # ensure_single_read's own message is phrased for check_binds
+            # (its only other caller today), so it's wrapped rather than
+            # surfaced bare here. TokenError is also caught: an unterminated
+            # string literal or comment fails sqlglot's tokenizer with a
+            # TokenError, a SqlglotError sibling of ParseError and not a
+            # subclass of ValueError -- despite ensure_single_read's
+            # docstring promising every rejection is a ValueError. Only
+            # TokenError, not the broader SqlglotError, is caught here: by
+            # the time control reaches this point `dialect` has already been
+            # validated once in load_contract_dir, so any other SqlglotError
+            # a future sqlglot version might raise from this call should
+            # surface as itself, not get relabeled as a rejected read.
+            raise ContractError(
+                f"{label}: 'reads.{name}' must be a single read query ({exc})"
+            ) from exc
 
     raw_columns = raw.get("output_columns")
     if not isinstance(raw_columns, list) or not raw_columns:
@@ -298,6 +278,8 @@ def parse_node(raw: dict[str, Any], source: str) -> Node:
     if not isinstance(description, str):
         raise ContractError(f"{label}: 'description' must be a string")
 
+    config = _validate_config(raw.get("config"), label)
+
     content_hash = raw.get("content_hash")
     if content_hash is not None and not isinstance(content_hash, str):
         raise ContractError(f"{label}: 'content_hash' must be a string")
@@ -313,16 +295,58 @@ def parse_node(raw: dict[str, Any], source: str) -> Node:
         output_columns=tuple(columns),
         description=description,
         extra_columns=extra_columns,
+        config=config,
         content_hash=content_hash,
     )
 
 
-def load_contract_dir(path: Path) -> list[Node]:
+def load_contract_dir(
+    path: Path, *, dialect: str | None = None, check_reads: bool = True
+) -> list[Node]:
     """Load and validate every `*.yml`/`*.yaml` contract file under ``path``.
 
-    Raises `ContractError` if no nodes are found, if any file's document is
-    malformed, or if two nodes across files share the same `(schema, table)`.
+    ``check_reads=False`` skips the per-read
+    :func:`~continuo_validation_contract.sql.ensure_single_read` gate and
+    nothing else; every other rule in :func:`parse_node` and every rule here
+    (dialect validity, document shape, duplicate relations, "no contract
+    files found") still runs. The runtime
+    (:func:`~continuo_python_runtime.harness.run_node`) passes it, because
+    re-running the read-shape gate at container start can only introduce a
+    disagreement, never catch a new problem:
+
+    - CI already gated the reads (``continuo-runtime validate``), under the
+      repo's own ``--dialect``, and Continuo gated them again with its own
+      parser and bind-check before promoting the release.
+    - The runtime has no ``--dialect`` of its own, so it would re-parse with
+      the dialect-neutral grammar — a *different* and in places stricter
+      grammar than CI used. Ordinary postgres (``a ~ 'x'``, ``data @>
+      '{...}'``) parses under ``--dialect postgres`` and not under the
+      neutral parser, so a team following the docs would get a green
+      validate, a green merge, an accepted release, and a node that fails on
+      every single run.
+    - Nothing at run time consumes the parse: ``ctx.read`` resolves declared
+      reads by name and hands the SQL to the adapter verbatim.
+
+    ``dialect`` is validated once, up front, then forwarded to
+    :func:`parse_node` for every node, so every declared read is checked
+    against that sqlglot dialect (``None`` -- the default -- uses sqlglot's
+    dialect-neutral parser). Validating it here rather than leaving it to
+    the per-read ``ensure_single_read`` call matters: an unrecognized
+    dialect name (e.g. a typo'd ``--dialect POSTGRES`` instead of
+    ``postgres``) raises the same bare ``ValueError`` a genuinely
+    unparseable read would, and would otherwise be misreported as a
+    rejected read instead of a bad flag -- blaming an innocent, valid read.
+
+    Raises `ContractError` if ``dialect`` is not a sqlglot dialect name, if
+    no nodes are found, if any file's document is malformed, or if two nodes
+    across files share the same `(schema, table)`.
     """
+    if dialect is not None:
+        try:
+            Dialect.get_or_raise(dialect)
+        except ValueError as exc:
+            raise ContractError(f"unknown --dialect {dialect!r}: {exc}") from exc
+
     files = sorted(path.glob("*.yml")) + sorted(path.glob("*.yaml"))
 
     nodes: list[Node] = []
@@ -348,7 +372,9 @@ def load_contract_dir(path: Path) -> list[Node]:
             raise ContractError(f"{file.name}: 'nodes' must be a list")
 
         for raw_node in raw_nodes:
-            node = parse_node(raw_node, file.name)
+            node = parse_node(
+                raw_node, file.name, dialect=dialect, check_reads=check_reads
+            )
             existing_source = relation_sources.get(node.relation)
             if existing_source is not None:
                 raise ContractError(

continuo_python_runtime/contract/merge.py

@@ -4,17 +4,22 @@ from pathlib import Path
 
 import yaml
 
+from continuo_python_runtime.closure import resolve_closure
 from continuo_python_runtime.contract.loader import load_contract_dir
 from continuo_python_runtime.contract.model import CONTRACT_VERSION, Node
 from continuo_python_runtime.contract.paths import resolve_script_path
-from continuo_python_runtime.hashing import content_hash
+from continuo_python_runtime.errors import ContractError
+from continuo_python_runtime.hashing import hash_parts
+from continuo_python_runtime.lint import lint_source
 
 
 def node_entry(node: Node) -> dict:
     """Convert a Node to its wire form dict.
 
-    Returns the node as a dict with all fields, output_columns as list of dicts,
-    and NO content_hash. The nullable field is always present in output_columns.
+    Returns the node as a dict with all fields, output_columns as list of
+    dicts. The entry carries no hash fields: build_wire_contract adds all
+    four (source_hash, shared_code_hash, config_hash, content_hash). The
+    nullable field is always present in output_columns.
     """
     return {
         "schema": node.schema,
@@ -34,29 +39,101 @@ def node_entry(node: Node) -> dict:
         ],
         "description": node.description,
         "extra_columns": node.extra_columns,
+        "config": dict(node.config),
     }
 
 
-def build_wire_contract(contract_dir: Path, repo_root: Path, service: str) -> dict:
+def _lint_node_closure(
+    node: Node,
+    repo_root: Path,
+    script_path: Path,
+    script_bytes: bytes,
+    closure: list[Path],
+    member_bytes: list[bytes],
+) -> None:
+    """Lint the node's script and every resolved closure member.
+
+    Every file that executes for this node — the script plus its transitive
+    in-repo import closure — is held to the same lint rules
+    (``continuo_python_runtime.lint.lint_source``: L1 forbidden driver
+    imports, L2 SQL string literals, L3 forbidden data-access calls, L4
+    private-attribute access, L5 dynamic-import constructs) that CI's
+    ``continuo-runtime lint`` applies to ``scripts/``. Enforcing it again
+    here, at merge time, means a helper file outside ``scripts/`` — which
+    the CI lint step never looks at — cannot become a side channel around
+    the harness's sole write sink, and the check cannot be defeated by a
+    stale or hand-edited workflow file: whatever produces the release
+    artifact is the thing that checked.
+
+    Paths in violation messages are repo-root-relative (``str(path.relative_to
+    (repo_root))``), so a message reads ``lib/shared.py:1: ...`` identically
+    in CI and on a laptop, never an absolute path that differs between the
+    two.
+
+    Raises ``ContractError`` naming the node and listing every violation
+    from every offending file — not just the first file's — so an author
+    can act on the full report in one pass instead of an iterative guessing
+    game.
+
+    Every file is decoded as ``"utf-8-sig"`` (identical to plain ``"utf-8"``
+    except that a leading BOM, if present, is stripped rather than kept as a
+    literal ``U+FEFF`` character) — this matches what ``ast.parse(bytes)``
+    already does for the same file in ``resolve_closure`` (bytes-mode
+    parsing treats a UTF-8 BOM as an implicit encoding declaration and
+    strips it), so a BOM file that parses and runs fine is not rejected here
+    on a mismatch between the two decoders. A file that isn't valid UTF-8 at
+    all (e.g. a PEP 263 ``# -*- coding: latin-1 -*-`` cookie plus a
+    non-ASCII byte — valid input to ``ast.parse(bytes)``, which honors the
+    cookie) raises ``UnicodeDecodeError``; that is caught and re-raised as a
+    ``ContractError`` naming the node and the offending repo-relative path,
+    so it joins the same error taxonomy as every other rejection here
+    instead of escaping as a bare stdlib exception past ``cli.main``, which
+    catches only ``HarnessError``/``OSError``.
+    """
+    repo_root_resolved = repo_root.resolve()
+    files = [(script_path, script_bytes), *zip(closure, member_bytes, strict=True)]
+
+    violations: list[str] = []
+    for path, data in files:
+        rel = path.relative_to(repo_root_resolved)
+        try:
+            text = data.decode("utf-8-sig")
+        except UnicodeDecodeError as exc:
+            raise ContractError(f"{node.relation}: {rel}: not valid UTF-8: {exc}") from exc
+        violations.extend(lint_source(text, str(rel)))
+
+    if violations:
+        report = "\n".join(violations)
+        raise ContractError(
+            f"{node.relation}: lint violations in script or import closure:\n{report}"
+        )
+
+
+def build_wire_contract(
+    contract_dir: Path, repo_root: Path, service: str, *, dialect: str | None = None
+) -> dict:
     """Build and return a wire contract document.
 
     Loads contracts from contract_dir, resolves script paths against repo_root,
     computes content hashes, and returns a contract document sorted by relation.
+    ``dialect`` is forwarded to :func:`~continuo_python_runtime.contract.loader
+    .load_contract_dir` so every declared read is checked against that sqlglot
+    dialect (``None`` -- the default -- uses sqlglot's dialect-neutral parser).
 
     Raises ContractError if any script file is missing.
     """
-    nodes = load_contract_dir(contract_dir)
+    nodes = load_contract_dir(contract_dir, dialect=dialect)
 
     wire_nodes = []
     for node in nodes:
         entry = node_entry(node)
 
         script_path = resolve_script_path(node.script, repo_root, context=node.relation)
-
-        # Read script bytes and compute hash
         script_bytes = script_path.read_bytes()
-        hash_value = content_hash(entry, script_bytes)
-        entry["content_hash"] = hash_value
+        closure = resolve_closure(script_path, repo_root)
+        member_bytes = [member.read_bytes() for member in closure]
+        _lint_node_closure(node, repo_root, script_path, script_bytes, closure, member_bytes)
+        entry.update(hash_parts(entry, script_bytes, member_bytes))
 
         wire_nodes.append(entry)
 

continuo_python_runtime/contract/model.py

@@ -1,6 +1,7 @@
 """Contract v1 model."""
 
-from dataclasses import dataclass
+from dataclasses import dataclass, field
+from typing import Any
 
 # Module-level constants
 CRITICALITIES = frozenset({"REGULATORY", "CORE", "SECONDARY"})
@@ -31,6 +32,7 @@ class Node:
     output_columns: tuple[Column, ...]
     description: str = ""
     extra_columns: str = "raise"
+    config: dict[str, Any] = field(default_factory=dict)
     content_hash: str | None = None
 
     @property

continuo_python_runtime/harness.py

@@ -71,15 +71,57 @@ def select_node(nodes: list[Node], node_id: str) -> Node:
     )
 
 
+def ensure_import_paths(repo_root: Path, script_dir: Path) -> None:
+    """Prepend ``repo_root`` then ``script_dir`` to ``sys.path``, idempotently.
+
+    ``importlib``'s ``spec_from_file_location`` + ``exec_module`` executes a
+    file without putting anything on ``sys.path``, and ``continuo-runtime`` is
+    an installed console script, so ``sys.path[0]`` is the venv's ``bin``
+    directory — ``/app`` is on no path. A node script importing its own
+    shared helpers (exactly what ``shared_code_hash`` folds into the content
+    hash) would therefore die with ``ModuleNotFoundError`` on its first
+    production run, having passed CI and the domain repo's own pytest, which
+    adds the rootdir to ``sys.path`` itself.
+
+    The two roots and their order mirror
+    :func:`continuo_python_runtime.closure._resolve_name`'s search roots, so a
+    name the closure resolver folded into the hash is a name the interpreter
+    can resolve: ``repo_root`` first (package-qualified ``import
+    scripts.helpers``, or a helper in a sibling ``lib/``), then the importing
+    script's own directory (sibling ``import helpers``).
+
+    Entries are left in place for the process lifetime rather than removed
+    after ``exec_module``: a script may import lazily inside ``run()``, and a
+    container runs exactly one node per process. Both paths are resolved
+    first, and each is unconditionally repositioned to the front rather than
+    left wherever it already was: the shipped images set ``PYTHONPATH=/app``,
+    so ``repo_root`` is *always* already on ``sys.path`` before this runs, and
+    merely skipping an already-present entry would leave it behind
+    ``script_dir`` -- the reverse of the required order. An existing entry is
+    removed before being reinserted at index 0, so repeated calls still
+    cannot grow ``sys.path`` or duplicate an entry, however the caller spelled
+    the roots or whatever order they were already in.
+    """
+    for entry in (str(script_dir.resolve()), str(repo_root.resolve())):
+        if entry in sys.path:
+            sys.path.remove(entry)
+        sys.path.insert(0, entry)
+
+
 def load_script(node: Node, repo_root: Path) -> ModuleType:
     """Import ``node.script`` (relative to ``repo_root``) and return the module.
 
+    ``repo_root`` and the script's own directory are put on ``sys.path`` first
+    (see :func:`ensure_import_paths`) so the script's in-repo import closure
+    is importable.
+
     Raises:
         ContractError: If the script path is absolute, escapes the
             repository root, or does not exist.
         ScriptError: If the module has no callable ``run``.
     """
     script_path = resolve_script_path(node.script, repo_root, context=node.relation)
+    ensure_import_paths(repo_root, script_path.parent)
 
     module_name = f"_continuo_node_{uuid.uuid4().hex}"
     spec = importlib.util.spec_from_file_location(module_name, script_path)
@@ -129,6 +171,42 @@ def _execute_script(module: ModuleType, ctx: RunContext) -> Any:
             raise ScriptError(f"run() raised {exc.__class__.__name__}: {exc}") from exc
 
 
+def _validate_config_early(adapter: Any, node: Node) -> None:
+    """Check ``node.config`` against the engine's vocabulary before anything runs.
+
+    ``ensure_table`` validates ``config`` too and stays the enforcement point —
+    but it is called *after* the script has executed and its result has been
+    conformed, so a single typo (``config: {index: [...]}``) burned the whole
+    node run before failing. This is the tripwire that fails it in the first
+    second instead. Validation-time checking of the same vocabulary is a future
+    cross-repo dependency (continuo-validation step 3a), and `continuo-runtime
+    validate` runs on a CI runner where no engine adapter is installed at all,
+    so this is the earliest point the engine's own rules can be applied.
+
+    The call is skipped for an adapter that does not provide ``validate_config``:
+    the abstract ``RuntimeAdapter`` in the pinned ``continuo-validation-contract``
+    does not declare it (this repo ships the harness and both adapters as one
+    coordinated release), and an adapter without it loses only earliness —
+    ``ensure_table`` still fails closed on the same config.
+
+    Raises:
+        LoadError: If the adapter rejects the config, matching how a rejection
+            from ``ensure_table`` surfaces.
+    """
+    validate = getattr(adapter, "validate_config", None)
+    if validate is None:
+        return
+    column_names = [c.name for c in node.output_columns]
+    try:
+        validate(node.config, column_names)
+    except HarnessError:
+        raise
+    except Exception as exc:
+        raise LoadError(
+            f"invalid config for {node.relation}: {exc}"
+        ) from exc
+
+
 def run_node(env: Mapping[str, str], adapter: Any = None) -> int:
     """Run a single node end-to-end and print exactly one sentinel result block.
 
@@ -146,12 +224,17 @@ def run_node(env: Mapping[str, str], adapter: Any = None) -> int:
 
         logger.info("running node %s -> %s.%s", node_id, target_schema, table_name)
 
-        nodes = load_contract_dir(contract_dir)
+        # check_reads=False: the harness has no --dialect of its own, so
+        # re-running the read-shape gate here would judge the reads against
+        # sqlglot's dialect-neutral grammar -- a different, in places stricter
+        # grammar than the one CI used -- and could only disagree with the
+        # gates already passed (CI's `continuo-runtime validate`, then
+        # Continuo's own parser and bind-check), never catch a new problem.
+        # ctx.read resolves declared reads by name and never parses them.
+        # Every other loader validation still runs at container start.
+        nodes = load_contract_dir(contract_dir, check_reads=False)
         node = select_node(nodes, node_id)
 
-        with contextlib.redirect_stdout(sys.stderr):
-            module = load_script(node, app_root)
-
         if adapter is not None:
             active_adapter = adapter
         else:
@@ -162,6 +245,11 @@ def run_node(env: Mapping[str, str], adapter: Any = None) -> int:
             except Exception as exc:
                 raise LoadError(f"adapter construction failed: {exc}") from exc
 
+        _validate_config_early(active_adapter, node)
+
+        with contextlib.redirect_stdout(sys.stderr):
+            module = load_script(node, app_root)
+
         ctx = RunContext(node, active_adapter)
         raw_result = _execute_script(module, ctx)
 
@@ -173,7 +261,7 @@ def run_node(env: Mapping[str, str], adapter: Any = None) -> int:
             for c in node.output_columns
         ]
         try:
-            active_adapter.ensure_table(target_schema, table_name, columns)
+            active_adapter.ensure_table(target_schema, table_name, columns, config=node.config)
             active_adapter.load(target_schema, table_name, conformed)
         except HarnessError:
             raise