tywrap 0.9.0 → 0.10.0

package/runtime/tywrap_bridge_core.py

@@ -47,6 +47,7 @@ import importlib
 import importlib.util
 import json
 import math
+import re
 import sys
 import traceback
 import uuid
@@ -57,6 +58,10 @@ from pathlib import Path, PurePath
 PROTOCOL = 'tywrap/1'
 PROTOCOL_VERSION = 1
 CODEC_VERSION = 1
+MAX_SERIALIZE_DEPTH = 900
+MAX_SERIALIZE_NODES = 1_000_000
+JS_SAFE_INTEGER_MAX = 2**53 - 1
+_SERIALIZE_PATH_IDENTIFIER = re.compile(r'^[A-Za-z_$][\w$]*$', re.ASCII)
 
 
 class ProtocolError(Exception):
@@ -376,7 +381,7 @@ def serialize_ndarray(obj, *, force_json_markers):
         ) from exc
     try:
         original_shape = list(obj.shape) if hasattr(obj, 'shape') else None
-        flat = obj.flatten() if hasattr(obj, 'ndim') and obj.ndim > 1 else obj
+        flat = obj.flatten() if hasattr(obj, 'ndim') and obj.ndim != 1 else obj
         arr = pa.array(flat)
         table = pa.Table.from_arrays([arr], names=['value'])
         sink = pa.BufferOutputStream()
@@ -397,7 +402,80 @@ def serialize_ndarray(obj, *, force_json_markers):
 
 
 def serialize_ndarray_json(obj):
-    """JSON fallback for ndarray (larger payloads, potential dtype loss)."""
+    """JSON fallback for ndarray values that JavaScript can represent safely."""
+    dtype = obj.dtype
+    dtype_label = str(dtype)
+
+    if not dtype.isnative:
+        raise RuntimeError(
+            f'JSON ndarray encoding does not support big-endian dtype={dtype_label}; '
+            "convert to native byte order with a.byteswap().view(a.dtype.newbyteorder('='))"
+        )
+
+    if dtype.kind in ('i', 'u'):
+        # JSON numbers become JavaScript Number values. Scan only on this explicit
+        # fallback path and reject before tolist() can silently round an integer.
+        if obj.size and (
+            (obj < -JS_SAFE_INTEGER_MAX).any() or (obj > JS_SAFE_INTEGER_MAX).any()
+        ):
+            raise RuntimeError(
+                f'JSON ndarray encoding cannot safely represent dtype={dtype_label} values '
+                'outside the JavaScript safe integer range; use Arrow encoding or '
+                "cast/encode explicitly (e.g. .astype('float64') or str)"
+            )
+    elif dtype.kind == 'M':
+        raise RuntimeError(
+            f'JSON ndarray encoding does not support dtype={dtype_label}; use Arrow encoding '
+            "or convert explicitly (e.g. .astype('datetime64[ms]').astype(str) or int with "
+            'declared unit)'
+        )
+    elif dtype.kind == 'm':
+        raise RuntimeError(
+            f'JSON ndarray encoding does not support dtype={dtype_label}; use Arrow encoding '
+            "or convert explicitly (e.g. .astype('timedelta64[ms]').astype(str) or int with "
+            'declared unit)'
+        )
+    elif dtype.kind == 'V':
+        if dtype.fields is not None:
+            raise RuntimeError(
+                f'JSON ndarray encoding does not support structured dtype={dtype_label}; '
+                'encode each named field explicitly (e.g. as a plain JSON object)'
+            )
+        raise RuntimeError(
+            f'JSON ndarray encoding does not support void dtype={dtype_label}; convert the '
+            "raw bytes explicitly (e.g. .view('uint8'))"
+        )
+    elif dtype.kind == 'O':
+        raise RuntimeError(
+            f'JSON ndarray encoding does not support object dtype={dtype_label}; cast to a '
+            'concrete numeric dtype or encode elements explicitly as plain JSON'
+        )
+    elif dtype.kind == 'S':
+        raise RuntimeError(
+            f'JSON ndarray encoding does not support byte-string dtype={dtype_label}; '
+            'decode elements and return a plain JSON list explicitly'
+        )
+    elif dtype.kind == 'U':
+        raise RuntimeError(
+            f'JSON ndarray encoding does not support unicode dtype={dtype_label}; convert '
+            'explicitly to plain JSON strings with .tolist()'
+        )
+    elif dtype.kind == 'c':
+        raise RuntimeError(
+            f'JSON ndarray encoding does not support complex dtype={dtype_label}; encode '
+            '.real and .imag arrays explicitly'
+        )
+    elif dtype.kind == 'f' and dtype.itemsize > 8:
+        raise RuntimeError(
+            f'JSON ndarray encoding does not support float dtype={dtype_label} wider than '
+            "64 bits; cast explicitly (e.g. .astype('float64')) or use Arrow encoding"
+        )
+    elif dtype.kind not in ('b', 'f'):
+        raise RuntimeError(
+            f'JSON ndarray encoding does not support dtype={dtype_label}; cast to bool, '
+            'integer, or float dtype, or encode values explicitly as plain JSON'
+        )
+
     try:
         data = obj.tolist()
     except Exception as exc:
@@ -408,6 +486,7 @@ def serialize_ndarray_json(obj):
         'encoding': 'json',
         'data': data,
         'shape': getattr(obj, 'shape', None),
+        'dtype': dtype.name,
     }
 
 
@@ -442,11 +521,42 @@ def serialize_dataframe(obj, *, force_json_markers):
 
 
 def serialize_dataframe_json(obj):
-    """JSON fallback for DataFrame: records orientation."""
+    """JSON fallback for DataFrame values that JavaScript can represent safely."""
+    import pandas as pd  # type: ignore
+
+    _validate_pandas_json_index(obj.index, pd, 'DataFrame')
+    json_columns = [_json_object_key(column) for column in obj.columns]
+    supported_json_columns = [column for column in json_columns if column is not None]
+    if not obj.columns.is_unique or len(set(supported_json_columns)) != len(
+        supported_json_columns
+    ):
+        raise RuntimeError(
+            'JSON pandas.DataFrame encoding requires column labels to remain unique after '
+            'JSON object-key coercion; rename columns or make them distinct before applying '
+            '.columns.astype(str)'
+        )
+    for column, dtype in obj.dtypes.items():
+        if isinstance(dtype, pd.CategoricalDtype):
+            raise RuntimeError(
+                f'JSON pandas.DataFrame encoding does not support categorical dtype in '
+                f'column {column!r}; use Arrow encoding or convert explicitly '
+                "(e.g. .astype(str))"
+            )
     try:
-        data = obj.to_dict(orient='records')
+        data = (
+            [{} for _ in range(len(obj.index))]
+            if len(obj.columns) == 0
+            else obj.to_dict(orient='records')
+        )
     except Exception as exc:
         raise RuntimeError('JSON fallback failed for pandas.DataFrame') from exc
+    for row_number, row in enumerate(data):
+        for column, value in row.items():
+            row[column] = _normalize_pandas_json_scalar(
+                value,
+                f'DataFrame cell at row {row_number}, column {column!r}',
+                pd,
+            )
     return {
         '__tywrap__': 'dataframe',
         'codecVersion': CODEC_VERSION,
@@ -488,14 +598,23 @@ def serialize_series(obj, *, force_json_markers):
 
 
 def serialize_series_json(obj):
-    """JSON fallback for Series (potentially lossy dtype/NA representation)."""
+    """JSON fallback for Series values that JavaScript can represent safely."""
+    import pandas as pd  # type: ignore
+
+    _validate_pandas_json_index(obj.index, pd, 'Series')
+    if isinstance(obj.dtype, pd.CategoricalDtype):
+        raise RuntimeError(
+            'JSON pandas.Series encoding does not support categorical dtype; use Arrow '
+            "encoding or convert explicitly (e.g. .astype(str))"
+        )
     try:
         data = obj.to_list()  # type: ignore
-    except Exception:
-        try:
-            data = obj.to_dict()  # type: ignore
-        except Exception as exc:
-            raise RuntimeError('JSON fallback failed for pandas.Series') from exc
+    except Exception as exc:
+        raise RuntimeError('JSON fallback failed for pandas.Series') from exc
+    data = [
+        _normalize_pandas_json_scalar(value, f'Series value at position {position}', pd)
+        for position, value in enumerate(data)
+    ]
     return {
         '__tywrap__': 'series',
         'codecVersion': CODEC_VERSION,
@@ -505,6 +624,70 @@ def serialize_series_json(obj):
     }
 
 
+def _validate_pandas_json_index(index, pd, container_name):
+    """Reject index metadata that records/list-oriented JSON would discard."""
+    if isinstance(index, pd.MultiIndex):
+        raise RuntimeError(
+            f'JSON pandas.{container_name} encoding does not support MultiIndex; use Arrow '
+            'encoding or flatten the index explicitly with .reset_index()'
+        )
+    if not (
+        isinstance(index, pd.RangeIndex)
+        and index.start == 0
+        and index.step == 1
+        and index.stop == len(index)
+        and index.name is None
+    ):
+        raise RuntimeError(
+            f'JSON pandas.{container_name} encoding requires an unnamed RangeIndex starting '
+            'at 0 with step 1; use Arrow encoding or normalize explicitly with '
+            '.reset_index(drop=True)'
+        )
+
+
+def _json_object_key(value):
+    """Return json.dumps' object-key spelling, or None for unsupported keys."""
+    try:
+        encoded = json.dumps({value: None})
+    except (TypeError, ValueError):
+        return None
+    return next(iter(json.loads(encoded)))
+
+
+def _normalize_pandas_json_scalar(value, location, pd):
+    """Normalize pandas nulls and reject values outside the plain JSON domain."""
+    np = sys.modules.get('numpy')
+    if np is not None and isinstance(value, np.generic):
+        value = value.item()
+    if value is None or value is pd.NA or value is pd.NaT:
+        return None
+    if type(value) is bool:
+        return value
+    if type(value) is int:
+        if value < -JS_SAFE_INTEGER_MAX or value > JS_SAFE_INTEGER_MAX:
+            raise RuntimeError(
+                f'JSON pandas encoding cannot safely represent {location} integer values '
+                'outside the JavaScript safe integer range; use Arrow encoding or '
+                "cast/encode explicitly (e.g. .astype('float64') or str)"
+            )
+        return value
+    if type(value) is float:
+        if not math.isfinite(value):
+            raise RuntimeError(
+                f'JSON pandas encoding cannot represent non-finite {location} float values '
+                '(NaN or Infinity); use .fillna(...) for intentional missing values or '
+                'Arrow encoding'
+            )
+        return value
+    if type(value) is str:
+        return value
+    raise RuntimeError(
+        f'JSON pandas encoding does not support {location} value of type '
+        f'{type(value).__name__}; use Arrow encoding or convert explicitly '
+        '(e.g. .astype(str))'
+    )
+
+
 def serialize_sparse_matrix(obj):
     """
     Serialize scipy sparse matrices into structured JSON envelopes (json-only;
@@ -575,12 +758,14 @@ def serialize_torch_tensor(obj, *, force_json_markers, torch_allow_copy=False):
     Rejection order is significant: the categorical rejections (sparse / quantized
     / meta / complex) are checked BEFORE the device/contiguous opt-in branch so
     they fail with a clear, specific message and are NOT bypassable by
-    TYWRAP_TORCH_ALLOW_COPY. The opt-in only governs the lossy-but-lossless device
-    transfer and contiguous copy, never an unrepresentable layout/dtype.
+    TYWRAP_TORCH_ALLOW_COPY. The opt-in only governs the device transfer and
+    contiguous copy, never an unrepresentable layout/dtype.
     """
     import torch  # already importable: is_torch_tensor() gated the dispatch
 
     tensor = obj.detach()
+    source_device = None
+    source_dtype = None
 
     # Sparse tensors (COO/CSR/CSC/BSR/BSC -> any non-strided layout) have no dense
     # numpy representation without a densify step, which is not the round-trip this
@@ -628,6 +813,7 @@ def serialize_torch_tensor(obj, *, force_json_markers, torch_allow_copy=False):
             raise RuntimeError(
                 'Torch tensor is on a non-CPU device; set TYWRAP_TORCH_ALLOW_COPY=1 to allow CPU transfer'
             )
+        source_device = str(tensor.device)
         tensor = tensor.to('cpu')
     if hasattr(tensor, 'is_contiguous') and not tensor.is_contiguous():
         if not torch_allow_copy:
@@ -635,12 +821,15 @@ def serialize_torch_tensor(obj, *, force_json_markers, torch_allow_copy=False):
                 'Torch tensor is not contiguous; set TYWRAP_TORCH_ALLOW_COPY=1 to allow contiguous copy'
             )
         tensor = tensor.contiguous()
+    if tensor.dtype == torch.bfloat16:
+        source_dtype = str(tensor.dtype)
+        tensor = tensor.float()
     try:
         arr = tensor.numpy()
     except Exception as exc:
         raise RuntimeError('Failed to convert torch.Tensor to numpy') from exc
 
-    return {
+    envelope = {
         '__tywrap__': 'torch.tensor',
         'codecVersion': CODEC_VERSION,
         'encoding': 'ndarray',
@@ -649,6 +838,11 @@ def serialize_torch_tensor(obj, *, force_json_markers, torch_allow_copy=False):
         'dtype': str(tensor.dtype),
         'device': str(tensor.device),
     }
+    if source_dtype is not None:
+        envelope['sourceDtype'] = source_dtype
+    if source_device is not None:
+        envelope['sourceDevice'] = source_device
+    return envelope
 
 
 def serialize_sklearn_estimator(obj):
@@ -727,34 +921,48 @@ def serialize_stdlib(obj):
     return None
 
 
-def serialize(obj, *, force_json_markers, torch_allow_copy=False):
-    """
-    Top-level result serializer.
+_NO_SCIENTIFIC = object()
 
-    Scientific codecs are type-first and only inspect packages that the value can
-    belong to. A value from an optional package implies that package is already in
-    sys.modules, so these checks never cold-import the scientific stack. The
-    package dispatch deliberately precedes the JSON-native fast path: e.g. a
-    package-defined subclass of dict still receives its relevant codec check.
-    The remaining BridgeCodec value behaviors (numpy/pandas scalars, bytes, sets,
-    complex rejection, NaN/Infinity) are applied later during JSON encoding by
-    default_encoder.
-    """
+
+def _check_serialize_depth(depth, path):
+    if depth > MAX_SERIALIZE_DEPTH:
+        raise RuntimeError(
+            f'Scientific envelope serialization maximum depth '
+            f'{MAX_SERIALIZE_DEPTH} exceeded at {path}'
+        )
+
+
+def _check_serialize_nodes(nodes, path):
+    if nodes > MAX_SERIALIZE_NODES:
+        raise RuntimeError(
+            f'Scientific envelope serialization maximum visited nodes '
+            f'{MAX_SERIALIZE_NODES} exceeded at {path}'
+        )
+
+
+def _serialize_scientific(obj, *, force_json_markers, torch_allow_copy, depth, path):
+    """Serialize a supported scientific value, or return _NO_SCIENTIFIC."""
     package = type(obj).__module__.split('.', 1)[0]
 
     if package == 'numpy' and 'numpy' in sys.modules:
         if is_numpy_array(obj):
+            _check_serialize_depth(depth, path)
             return serialize_ndarray(obj, force_json_markers=force_json_markers)
     elif package == 'pandas' and 'pandas' in sys.modules:
         if is_pandas_dataframe(obj):
+            _check_serialize_depth(depth, path)
             return serialize_dataframe(obj, force_json_markers=force_json_markers)
         if is_pandas_series(obj):
+            _check_serialize_depth(depth, path)
             return serialize_series(obj, force_json_markers=force_json_markers)
     elif package == 'scipy' and 'scipy.sparse' in sys.modules:
         if is_scipy_sparse(obj):
+            _check_serialize_depth(depth, path)
             return serialize_sparse_matrix(obj)
     elif package == 'torch' and 'torch' in sys.modules:
         if is_torch_tensor(obj):
+            _check_serialize_depth(depth, path)
+            _check_serialize_depth(depth + 1, _serialize_path(path, 'value'))
             return serialize_torch_tensor(
                 obj, force_json_markers=force_json_markers, torch_allow_copy=torch_allow_copy
             )
@@ -763,18 +971,168 @@ def serialize(obj, *, force_json_markers, torch_allow_copy=False):
         # BaseEstimator is sklearn's documented extension point, so user-defined
         # estimators live outside the 'sklearn' package and must still get the
         # estimator serializer (and its param-naming errors).
+        _check_serialize_depth(depth, path)
         return serialize_sklearn_estimator(obj)
 
-    if isinstance(obj, (type(None), bool, int, float, str, dict, list, tuple)):
-        return obj
+    return _NO_SCIENTIFIC
+
+
+def _serialize_path(base, key):
+    """Build a decoder-compatible JSONPath-like result path."""
+    if isinstance(key, int):
+        return f'{base}[{key}]'
+    if _SERIALIZE_PATH_IDENTIFIER.fullmatch(key):
+        return f'{base}.{key}'
+    return f'{base}[{json.dumps(key, ensure_ascii=False)}]'
+
+
+def _invalid_key_path(base, key):
+    """Name a dict key that cannot be represented by JSON."""
+    return f'{base}[{key!r}]'
 
-    pydantic_value = serialize_pydantic(obj)
+
+def _needs_serialize_visit(value):
+    """Return whether value needs container or scientific traversal work."""
+    if type(value) in (type(None), bool, int, float, str):
+        return False
+    if type(value) in (dict, list, tuple):
+        return True
+    package = type(value).__module__.split('.', 1)[0]
+    if package in ('numpy', 'pandas', 'scipy', 'torch'):
+        return True
+    return 'sklearn.base' in sys.modules and is_sklearn_estimator(value)
+
+
+def _serialize_leaf(value):
+    """Apply non-container conversions without allocating a traversal frame."""
+    if type(value) in (type(None), bool, int, float, str):
+        return value
+    pydantic_value = serialize_pydantic(value)
     if pydantic_value is not _NO_PYDANTIC:
         return pydantic_value
-    stdlib_value = serialize_stdlib(obj)
+    stdlib_value = serialize_stdlib(value)
     if stdlib_value is not None:
         return stdlib_value
-    return obj
+    return value
+
+
+def serialize(obj, *, force_json_markers, torch_allow_copy=False):
+    """
+    Top-level result serializer.
+
+    Scientific codecs are type-first and only inspect packages that the value can
+    belong to. A value from an optional package implies that package is already in
+    sys.modules, so these checks never cold-import the scientific stack. The
+    package dispatch deliberately precedes the JSON-native fast path: e.g. a
+    package-defined subclass of dict still receives its relevant codec check.
+    Every other value is left untouched so the shared JSON encoder applies the
+    exact same default conversion at the root and at any nested depth.
+    """
+    root = [None]
+    active_ids = set()
+    stack = [('visit', obj, 0, 'result', root, 0)]
+    visited_nodes = 0
+
+    # Repeated aliases have value semantics and are intentionally serialized twice.
+    while stack:
+        frame = stack.pop()
+        action = frame[0]
+        if action == 'dict':
+            _, current, depth, path, parent, key, output, iterator = frame
+            try:
+                item_key, item = next(iterator)
+            except StopIteration:
+                active_ids.remove(id(current))
+                parent[key] = output
+                continue
+            stack.append(frame)
+            if not (isinstance(item_key, (str, int, float, bool)) or item_key is None):
+                invalid_path = _invalid_key_path(path, item_key)
+                raise TypeError(
+                    f'keys must be str, int, float, bool or None, not '
+                    f'{type(item_key).__name__} at {invalid_path}'
+                )
+            child_key = _json_object_key(item_key)
+            child_path = _serialize_path(path, child_key)
+            if _needs_serialize_visit(item):
+                stack.append(('visit', item, depth + 1, child_path, output, item_key))
+            else:
+                output[item_key] = _serialize_leaf(item)
+            continue
+        if action == 'sequence':
+            _, current, depth, path, parent, key, output, index = frame
+            if index == len(output):
+                active_ids.remove(id(current))
+                parent[key] = output if type(current) is list else tuple(output)
+                continue
+            stack.append(('sequence', current, depth, path, parent, key, output, index + 1))
+            item = current[index]
+            if _needs_serialize_visit(item):
+                stack.append(
+                    ('visit', item, depth + 1, _serialize_path(path, index), output, index)
+                )
+            else:
+                output[index] = _serialize_leaf(item)
+            continue
+
+        _, current, depth, path, parent, key = frame
+        try:
+            scientific = _serialize_scientific(
+                current,
+                force_json_markers=force_json_markers,
+                torch_allow_copy=torch_allow_copy,
+                depth=depth,
+                path=path,
+            )
+        except Exception as exc:
+            if path == 'result':
+                raise
+            raise RuntimeError(f'Scientific value serialization failed at {path}: {exc}') from exc
+        if scientific is not _NO_SCIENTIFIC:
+            # Recognized envelopes are terminal containers to the JS decoder.
+            visited_nodes += 1
+            _check_serialize_nodes(visited_nodes, path)
+            if scientific.get('__tywrap__') == 'torch.tensor':
+                nested_path = _serialize_path(path, 'value')
+                try:
+                    visited_nodes += 1
+                    _check_serialize_nodes(visited_nodes, nested_path)
+                except Exception as exc:
+                    if path == 'result':
+                        raise
+                    raise RuntimeError(
+                        f'Scientific value serialization failed at {path}: {exc}'
+                    ) from exc
+            parent[key] = scientific
+            continue
+
+        container_type = type(current)
+        if container_type in (dict, list, tuple):
+            _check_serialize_depth(depth, path)
+            visited_nodes += 1
+            _check_serialize_nodes(visited_nodes, path)
+            current_id = id(current)
+            if current_id in active_ids:
+                raise RuntimeError(f'Circular reference detected at {path}')
+            active_ids.add(current_id)
+
+            if container_type is dict:
+                output = {}
+                parent[key] = output
+                stack.append(
+                    ('dict', current, depth, path, parent, key, output, iter(current.items()))
+                )
+                continue
+
+            output = [None] * len(current)
+            if container_type is list:
+                parent[key] = output
+            stack.append(('sequence', current, depth, path, parent, key, output, 0))
+            continue
+
+        parent[key] = _serialize_leaf(current)
+
+    return root[0]
 
 
 # =============================================================================
@@ -839,20 +1197,9 @@ def make_default_encoder(*, allow_nan):
                 if isinstance(obj, pd.Timedelta):
                     return obj.total_seconds()
 
-        if isinstance(obj, dt.datetime):
-            return obj.isoformat()
-        if isinstance(obj, dt.date):
-            return obj.isoformat()
-        if isinstance(obj, dt.time):
-            return obj.isoformat()
-        if isinstance(obj, dt.timedelta):
-            return obj.total_seconds()
-        if isinstance(obj, decimal.Decimal):
-            return str(obj)
-        if isinstance(obj, uuid.UUID):
-            return str(obj)
-        if isinstance(obj, (Path, PurePath)):
-            return str(obj)
+        stdlib_value = serialize_stdlib(obj)
+        if stdlib_value is not None:
+            return stdlib_value
 
         if isinstance(obj, (bytes, bytearray)):
             return {
@@ -896,12 +1243,10 @@ def encode_value(value, *, allow_nan):
         # ("...not JSON compliant: nan"), but 3.10/3.11 emit only the canonical
         # "Out of range float values are not JSON compliant". Match that phrase too
         # so the typed error message is stable across versions.
+        nonfinite_token = re.search(r'(^|[^a-z])(nan|inf|infinity)([^a-z]|$)', error_msg)
         if (
-            'nan' in error_msg
-            or 'infinity' in error_msg
-            or 'inf' in error_msg
-            or 'out of range float' in error_msg
-        ):
+            not allow_nan and 'out of range float values are not json compliant' in error_msg
+        ) or nonfinite_token:
             raise CodecError('Cannot serialize NaN - NaN/Infinity not allowed in JSON') from exc
         raise CodecError(f'JSON encoding failed: {exc}') from exc
     except TypeError as exc:

package/src/core/generator.ts

@@ -512,6 +512,21 @@ export class CodeGenerator {
           if (leaf === 'ndarray' || leaf === 'NDArray' || full.includes('numpy')) {
             return { kind: 'marker', marker: 'ndarray' };
           }
+          if (
+            ['csr_matrix', 'csc_matrix', 'coo_matrix', 'spmatrix'].includes(leaf) &&
+            (!current.module || current.module.startsWith('scipy'))
+          ) {
+            return { kind: 'marker', marker: 'scipy.sparse' };
+          }
+          if (leaf === 'Tensor' && (!current.module || current.module.startsWith('torch'))) {
+            return { kind: 'marker', marker: 'torch.tensor' };
+          }
+          if (
+            leaf === 'BaseEstimator' &&
+            (!current.module || current.module.startsWith('sklearn'))
+          ) {
+            return { kind: 'marker', marker: 'sklearn.estimator' };
+          }
           return definitions.has(leaf) ? { kind: 'ref', name: leaf } : { kind: 'any' };
         }
         case 'typevar':