Fix list/dict constant resolution and numeric key handling

Runtime: auto-promoted constants containing wired refs (e.g.
["{obj1}", "{obj2}"]) now resolve correctly via _resolve_runtime
instead of crashing in _format_string_constant.

Formats: all three input adapters (toml_to_spec, json_to_spec,
ini_to_spec) now convert top-level numeric string keys to integers
for positional argument support. Conversion is shallow — nested dicts
keep string keys, since _separate_args_kwargs only dispatches on
top-level keys. spec_to_toml converts int keys back to strings.

Uses Mapping for input params to avoid dict invariance casts.

Author: alganet

apywire/compiler.py

@@ -14,6 +14,7 @@
 
 from apywire.constants import (
     CACHE_ATTR_PREFIX,
+    PLACEHOLDER_REGEX,
     SYNTHETIC_CONST,
 )
 from apywire.wiring import (
@@ -258,9 +259,7 @@ def _compile_property(
 
         if not thread_safe:
             assign_cache = self._create_cache_assignment(cache_attr, call)
-            if_stmt = ast.If(
-                test=has_check, body=[assign_cache], orelse=[]
-            )
+            if_stmt = ast.If(test=has_check, body=[assign_cache], orelse=[])
             func_def = ast.FunctionDef(
                 name=name,
                 args=_PROPERTY_ARGS,
@@ -282,9 +281,7 @@ def _compile_property(
                 args=[ast.Constant(value=name), maker],
                 keywords=[],
             )
-            assign_cache = self._create_cache_assignment(
-                cache_attr, call_inst
-            )
+            assign_cache = self._create_cache_assignment(cache_attr, call_inst)
             func_def = ast.FunctionDef(
                 name=name,
                 args=_PROPERTY_ARGS,
@@ -321,6 +318,119 @@ def _compile_constant_property(
             type_params=[],
         )
 
+    def _astify_interpolated_string(self, template: str) -> ast.expr:
+        """Build an AST f-string from a template with placeholders.
+
+        Turns ``"Hello {name}"`` into ``f"Hello {str(self.name())}"``.
+        Each ``{ref}`` becomes a ``FormattedValue`` calling the
+        accessor and converting to ``str()``.
+        """
+        parts: list[ast.expr | ast.Constant] = []
+        last_end = 0
+        for match in PLACEHOLDER_REGEX.finditer(template):
+            # Add literal text before this placeholder
+            if match.start() > last_end:
+                parts.append(ast.Constant(template[last_end : match.start()]))
+            # Add formatted value: str(self.name())
+            ref_name = match.group(1)
+            accessor_call = ast.Call(
+                func=ast.Attribute(
+                    value=ast.Name(id="self", ctx=ast.Load()),
+                    attr=ref_name,
+                    ctx=ast.Load(),
+                ),
+                args=[],
+                keywords=[],
+            )
+            str_call = ast.Call(
+                func=ast.Name(id="str", ctx=ast.Load()),
+                args=[accessor_call],
+                keywords=[],
+            )
+            parts.append(
+                ast.FormattedValue(
+                    value=str_call,
+                    conversion=-1,
+                    format_spec=None,
+                )
+            )
+            last_end = match.end()
+        # Add trailing literal
+        if last_end < len(template):
+            parts.append(ast.Constant(template[last_end:]))
+        return ast.JoinedStr(values=parts)
+
+    def _compile_promoted_constant(
+        self,
+        name: str,
+        data: _ResolvedValue,
+        *,
+        thread_safe: bool = False,
+    ) -> ast.FunctionDef:
+        """Build an AST FunctionDef for an auto-promoted constant.
+
+        Auto-promoted constants are values (strings, lists, dicts)
+        that reference wired objects via placeholders. They are
+        compiled as cached accessors that resolve wired refs at
+        call time.
+        """
+        if isinstance(data, str):
+            value_expr = self._astify_interpolated_string(data)
+        else:
+            value_expr = self._astify(data)
+        cache_attr = f"{CACHE_ATTR_PREFIX}{name}"
+        has_check = self._create_cache_check(cache_attr)
+        return_stmt = self._create_return_statement(cache_attr)
+
+        if not thread_safe:
+            assign_cache = self._create_cache_assignment(
+                cache_attr, value_expr
+            )
+            return ast.FunctionDef(
+                name=name,
+                args=_PROPERTY_ARGS,
+                body=[
+                    ast.If(
+                        test=has_check,
+                        body=[assign_cache],
+                        orelse=[],
+                    ),
+                    return_stmt,
+                ],
+                decorator_list=[],
+                returns=None,
+                type_comment=None,
+                type_params=[],
+            )
+        else:
+            maker = self._create_lambda_function(value_expr)
+            call_inst = ast.Call(
+                func=ast.Attribute(
+                    value=ast.Name(id="self", ctx=ast.Load()),
+                    attr="_instantiate_attr",
+                    ctx=ast.Load(),
+                ),
+                args=[ast.Constant(value=name), maker],
+                keywords=[],
+            )
+            assign_cache = self._create_cache_assignment(cache_attr, call_inst)
+            return ast.FunctionDef(
+                name=name,
+                args=_PROPERTY_ARGS,
+                body=[
+                    ast.If(
+                        test=has_check,
+                        body=[assign_cache],
+                        orelse=[],
+                    ),
+                    return_stmt,
+                ],
+                decorator_list=[],
+                returns=None,
+                type_comment=None,
+                type_params=[],
+            )
+
     def compile(self, *, aio: bool = False, thread_safe: bool = False) -> str:
         """Compiles the Spec into a string containing Python code.
 
@@ -423,9 +533,7 @@ def compile(self, *, aio: bool = False, thread_safe: bool = False) -> str:
         for cname, cvalue in constant_names.items():
             cache_attr = f"{CACHE_ATTR_PREFIX}{cname}"
             init_body.append(
-                self._create_cache_assignment(
-                    cache_attr, ast.Constant(cvalue)
-                )
+                self._create_cache_assignment(cache_attr, ast.Constant(cvalue))
             )
         if init_body:
             init_def = ast.FunctionDef(
@@ -439,12 +547,19 @@ def compile(self, *, aio: bool = False, thread_safe: bool = False) -> str:
             class_body.insert(0, init_def)
 
         for name, entry in self._parsed.items():
-            # Skip synthetic auto-promoted constants
-            # These require runtime interpolation and can't be pre-computed
             if (
                 entry.module_name == SYNTHETIC_CONST
                 and entry.class_name == "str"
             ):
+                # Auto-promoted constant with wired refs.
+                # Compile as a cached accessor that resolves refs.
+                class_body.append(
+                    self._compile_promoted_constant(
+                        name,
+                        entry.data,
+                        thread_safe=thread_safe,
+                    )
+                )
                 continue
 
             class_body.append(

apywire/formats.py

@@ -9,6 +9,7 @@
 import configparser
 import json
 from types import ModuleType
+from collections.abc import Mapping
 from typing import cast
 
 from apywire.exceptions import FormatError
@@ -151,7 +152,10 @@ def ini_to_spec(content: str) -> Spec:
                 value = config[section][key]
                 parsed = _parse_ini_value(value)
                 section_dict[key] = cast(_ConstantValue, parsed)
-            spec[section] = cast(_SpecMapping, section_dict)
+            spec[section] = cast(
+                _SpecMapping,
+                _convert_numeric_keys(section_dict),
+            )
     return spec
 
 
@@ -181,7 +185,10 @@ def spec_to_toml(spec: Spec) -> str:
         raise FormatError("toml", "TOML output requires tomli_w.")
     toml_dict: dict[str, object] = {}
     for key, value in spec.items():
-        toml_dict[key] = value
+        if isinstance(value, dict):
+            toml_dict[key] = _stringify_int_keys(value)
+        else:
+            toml_dict[key] = value
     result: str = _tomli_w.dumps(toml_dict)
     return result
 
@@ -219,12 +226,50 @@ def toml_to_spec(content: str) -> Spec:
     spec: Spec = {}
     for key, value in data.items():
         if isinstance(value, dict):
-            spec[key] = cast(_SpecMapping, value)
+            spec[key] = cast(_SpecMapping, _convert_numeric_keys(value))
         else:
             spec[key] = cast(_ConstantValue, value)
     return spec
 
 
+def _stringify_int_keys(
+    d: Mapping[str | int, object],
+) -> dict[str, object]:
+    """Convert top-level integer keys back to strings for serialization.
+
+    The inverse of ``_convert_numeric_keys``. Only converts the
+    top level — nested dicts are left unchanged because only
+    top-level int keys represent positional arguments.
+    """
+    return {str(k): v for k, v in d.items()}
+
+
+def _convert_numeric_keys(
+    d: Mapping[str | int, object],
+) -> dict[str | int, object]:
+    """Convert top-level numeric string keys to integers.
+
+    File formats (TOML, JSON, INI) use string keys, but apywire
+    uses integer keys for positional arguments. This converts
+    keys like ``"0"``, ``"1"`` to ``0``, ``1``.
+
+    Only converts the top level of the dict — nested dicts keep
+    their string keys, since ``_separate_args_kwargs`` only checks
+    the top level for positional vs keyword argument dispatch.
+    """
+    result: dict[str | int, object] = {}
+    for k, v in d.items():
+        # Only convert canonical decimal representations (no leading
+        # zeros) to avoid "00"/"01" silently colliding with "0"/"1".
+        new_key: str | int
+        if isinstance(k, str) and k.isdigit() and str(int(k)) == k:
+            new_key = int(k)
+        else:
+            new_key = k
+        result[new_key] = v
+    return result
+
+
 def spec_to_json(spec: Spec) -> str:
     """Convert a spec dict to JSON format string.
 
@@ -264,8 +309,24 @@ def json_to_spec(content: str) -> Spec:
         2025
     """
     try:
-        result: Spec = json.loads(content)
+        raw: object = json.loads(content)
     except Exception as e:
-        raise FormatError("json", f"Failed to parse JSON content: {e}") from e
-
-    return result
+        raise FormatError(
+            "json", f"Failed to parse JSON content: {e}"
+        ) from e
+
+    if not isinstance(raw, dict):
+        raise FormatError(
+            "json",
+            "JSON root must be an object, "
+            f"got {type(raw).__name__}",
+        )
+
+    data: dict[str, object] = raw
+    spec: Spec = {}
+    for key, value in data.items():
+        if isinstance(value, dict):
+            spec[key] = cast(_SpecMapping, _convert_numeric_keys(value))
+        else:
+            spec[key] = cast(_ConstantValue, value)
+    return spec

apywire/runtime.py

@@ -198,10 +198,15 @@ def _instantiate_impl(self, name: str) -> _RuntimeValue:
 
         # Check for synthetic auto-promoted constant
         if entry.module_name == SYNTHETIC_CONST and entry.class_name == "str":
-            # This is an auto-promoted constant with string interpolation
-            value = self._format_string_constant(entry.data, context=name)
-            self._values[name] = value
-            return value
+            result: _RuntimeValue
+            if isinstance(entry.data, str):
+                # String template with interpolation
+                result = self._format_string_constant(entry.data, context=name)
+            else:
+                # Non-string (list, dict, tuple) with wired refs
+                result = self._resolve_runtime(entry.data, context=name)
+            self._values[name] = result
+            return result
 
         module = importlib.import_module(entry.module_name)
         cls = cast(_Constructor, getattr(module, entry.class_name))