fixtureqa 0.9.8__tar.gz → 0.10.0__tar.gz

{fixtureqa-0.9.8/fixtureqa.egg-info → fixtureqa-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fixtureqa
-Version: 0.9.8
+Version: 0.10.0
 Summary: FIXture — FIX Protocol Testing Tool
 Requires-Python: >=3.10
 License-File: LICENSE

{fixtureqa-0.9.8 → fixtureqa-0.10.0}/fixture/api/routers/fix_spec.py

@@ -11,37 +11,55 @@ from ...core.user_store import User
 from ..deps import get_current_user, get_spec_overlay_store, get_spec_store
 from ..schemas import FieldRefResponse, MessageDefResponse, MessageSummaryResponse
 
-router = APIRouter(tags=["fix-spec"])
+from fixcore.message import bundled_app_specs, bundled_begin_strings
 
-SUPPORTED = {"FIX.4.2", "FIX.4.4"}
-BUNDLED = {"FIX42.xml", "FIX44.xml"}
+router = APIRouter(tags=["fix-spec"])
 
 SO = Annotated[SpecOverlayStore, Depends(get_spec_overlay_store)]
 SS = Annotated[SpecStore, Depends(get_spec_store)]
 CurrentUser = Annotated[User, Depends(get_current_user)]
 
 
+def _supported() -> set[str]:
+    """Selectable BeginStrings — every transport-capable bundled spec."""
+    return set(bundled_begin_strings().values())
+
+
+def _bundled_names() -> set[str]:
+    """All bundled spec filenames accepted as an explicit ``spec`` override
+    (transport specs + FIX 5.0 application specs)."""
+    return set(bundled_begin_strings()) | set(bundled_app_specs())
+
+
 def _validate_begin_string(begin_string: str) -> None:
-    if begin_string not in SUPPORTED:
+    if begin_string not in _supported():
         raise HTTPException(
             status_code=400,
-            detail=f"Unsupported begin_string '{begin_string}'. Use: {sorted(SUPPORTED)}",
+            detail=f"Unsupported begin_string '{begin_string}'. Use: {sorted(_supported())}",
         )
 
 
+def _is_allowed_spec(spec: str, user: User, spec_store: SpecStore) -> bool:
+    """A ``spec`` override is allowed if it's a bundled name, a bundled
+    ``transport+app`` combined ref, or a custom upload the caller owns."""
+    bundled = _bundled_names()
+    if "+" in spec:
+        return all(part in bundled for part in spec.split("+", 1))
+    return spec in bundled or spec_store.owns_path(user.uid, spec)
+
+
 def _resolve_spec_ref(
     begin_string: str, spec: str | None, user: User, spec_store: SpecStore
 ) -> str:
-    """The fixcore spec ref to browse: an explicit ``spec`` (a bundled name, or a
-    custom upload the caller owns) overrides the version-derived bundled spec.
+    """The fixcore spec ref to browse: an explicit ``spec`` (a bundled name, a
+    ``transport+app`` combined ref, or a custom upload the caller owns) overrides
+    the version-derived bundled spec.
 
     A custom path the caller doesn't own is rejected so the browser can't be
     used to read arbitrary files.
     """
     if spec:
-        if spec in BUNDLED:
-            return spec
-        if spec_store.owns_path(user.uid, spec):
+        if _is_allowed_spec(spec, user, spec_store):
             return spec
         raise HTTPException(status_code=403, detail="Spec not accessible")
     _validate_begin_string(begin_string)

{fixtureqa-0.9.8 → fixtureqa-0.10.0}/fixture/api/routers/sessions.py

@@ -17,19 +17,23 @@ SS = Annotated[SpecStore, Depends(get_spec_store)]
 CurrentUser = Annotated[User, Depends(get_current_user)]
 OwnedSession = Annotated[SessionConfig, Depends(get_owned_session)]
 
-# Bundled spec names fixcore resolves by itself (see core.spec_store).
-_BUNDLED_SPECS = {"FIX42.xml", "FIX44.xml"}
+def _bundled_specs() -> set[str]:
+    """Bundled spec names fixcore resolves by itself — transport dictionaries
+    (FIX 4.x + FIXT.1.1) plus the FIX 5.0 application dictionaries."""
+    from fixcore.message import bundled_app_specs, bundled_begin_strings
+    return set(bundled_begin_strings()) | set(bundled_app_specs())
 
 
 def _validate_data_dictionary(value: Optional[str], user: User, spec_store: SpecStore) -> None:
     """A session may reference a bundled spec or a custom upload it owns — never
-    an arbitrary filesystem path (which would let it read any file on start)."""
-    if not value or value in _BUNDLED_SPECS:
+    an arbitrary filesystem path (which would let it read any file on start).
+    Covers both data_dictionary_path and a FIXT session's app_data_dictionary."""
+    if not value or value in _bundled_specs():
         return
     if not spec_store.owns_path(user.uid, value):
         raise HTTPException(
             status_code=400,
-            detail="data_dictionary_path must be a bundled spec name or one of your uploaded specs",
+            detail="dictionary must be a bundled spec name or one of your uploaded specs",
         )
 
 
@@ -109,6 +113,8 @@ def _session_response(sm: SessionManager, session_id: str, us: Optional[UserStor
         auto_fill=cfg.auto_fill,
         auto_fill_delay_ms=cfg.auto_fill_delay_ms,
         data_dictionary_path=cfg.data_dictionary_path,
+        app_data_dictionary=cfg.app_data_dictionary,
+        default_appl_ver_id=cfg.default_appl_ver_id,
         status=state.status.name,
         last_sent_seq_num=state.last_sent_seq_num,
         last_recv_seq_num=state.last_recv_seq_num,
@@ -135,6 +141,7 @@ def list_sessions(sm: SM, us: US, user: CurrentUser):
 @router.post("/", response_model=SessionResponse, status_code=201)
 async def create_session(body: SessionConfigRequest, sm: SM, us: US, ss: SS, user: CurrentUser):
     _validate_data_dictionary(body.data_dictionary_path, user, ss)
+    _validate_data_dictionary(body.app_data_dictionary, user, ss)
     cfg = _config_from_request(body, owner_uid=user.uid)
 
     try:
@@ -173,6 +180,7 @@ def import_sessions(body: list[SessionConfigRequest], sm: SM, us: US, ss: SS, us
     for item in body:
         try:
             _validate_data_dictionary(item.data_dictionary_path, user, ss)
+            _validate_data_dictionary(item.app_data_dictionary, user, ss)
             cfg = _config_from_request(item, owner_uid=user.uid)
             session_id = sm.add_session(cfg)
         except (HTTPException, ValueError, KeyError):
@@ -190,6 +198,8 @@ def get_session(session_id: str, _cfg: OwnedSession, sm: SM, us: US, user: Curre
 def update_session(session_id: str, body: UpdateSessionRequest, _cfg: OwnedSession, sm: SM, us: US, ss: SS, user: CurrentUser):
     if "data_dictionary_path" in body.model_fields_set:
         _validate_data_dictionary(body.data_dictionary_path, user, ss)
+    if "app_data_dictionary" in body.model_fields_set:
+        _validate_data_dictionary(body.app_data_dictionary, user, ss)
     try:
         sm.update_session(session_id, body)
     except RuntimeError as e:

{fixtureqa-0.9.8 → fixtureqa-0.10.0}/fixture/api/routers/specs.py

@@ -1,8 +1,8 @@
 """Custom FIX spec (DataDictionary) upload/list/delete.
 
-Bundled specs (FIX42.xml / FIX44.xml) ship inside fixcore; this router manages
-the per-user *custom* uploads and lists both together so the session builder can
-offer one combined dropdown.
+Bundled specs (FIX 4.0–4.4, FIXT11 + FIX50x) ship inside fixcore; this router
+manages the per-user *custom* uploads and lists them together so the session
+builder can offer one combined dropdown.
 """
 
 from typing import Annotated

{fixtureqa-0.9.8 → fixtureqa-0.10.0}/fixture/api/schemas.py

@@ -23,6 +23,8 @@ class SessionConfigRequest(BaseModel):
     send_redundant_resend_requests: bool = False
     enable_last_msg_seq_num_processed: bool = False  # stamp LastMsgSeqNumProcessed(369)
     data_dictionary_path: Optional[str] = None
+    app_data_dictionary: Optional[str] = None  # FIXT.1.1: FIX 5.0 application spec
+    default_appl_ver_id: str = ""              # FIXT.1.1: tag 1137 (7/8/9 or label)
     use_file_log: bool = True
     start_time: str = "00:00:00"
     end_time: str = "00:00:00"
@@ -92,6 +94,8 @@ class SessionResponse(BaseModel):
     auto_fill: bool
     auto_fill_delay_ms: int
     data_dictionary_path: Optional[str]
+    app_data_dictionary: Optional[str]
+    default_appl_ver_id: str
     status: str
     last_sent_seq_num: int
     last_recv_seq_num: int
@@ -122,6 +126,8 @@ class UpdateSessionRequest(BaseModel):
     send_redundant_resend_requests: Optional[bool] = None
     enable_last_msg_seq_num_processed: Optional[bool] = None
     data_dictionary_path: Optional[str] = None
+    app_data_dictionary: Optional[str] = None
+    default_appl_ver_id: Optional[str] = None
     use_file_log: Optional[bool] = None
     start_time: Optional[str] = None
     end_time: Optional[str] = None

{fixtureqa-0.9.8 → fixtureqa-0.10.0}/fixture/core/fix_spec_parser.py

@@ -2,27 +2,38 @@
 Structured FIX field/message definitions for the GUI spec browser.
 
 This is a thin adapter over fixcore's :class:`~fixcore.message.DataDictionary`
-— fixture no longer parses spec XML itself. fixcore 0.9.x bundles the FIX 4.2 /
-4.4 dictionaries and (crucially) expands ``<component>`` references, so the
-field lists here are complete for FIX 4.4 (NewOrderSingle's Instrument /
+— fixture no longer parses spec XML itself. fixcore bundles the FIX 4.0–4.4 and
+FIX 5.0 (FIXT.1.1) dictionaries and (crucially) expands ``<component>``
+references, so the field lists here are complete (NewOrderSingle's Instrument /
 OrderQtyData / Parties fields, etc.) where the old in-house parser silently
 dropped every component-sourced field.
 
-A *spec ref* is whatever fixcore's ``load_data_dictionary`` accepts: a bundled
-spec name (``"FIX42.xml"`` / ``"FIX44.xml"``) or an absolute path to a custom
-uploaded spec.
+A *spec ref* is whatever :func:`_load_dd` accepts: a bundled spec name
+(``"FIX42.xml"``), an absolute path to a custom uploaded spec, or a
+``transport+app`` pair for FIX 5.0 (``"FIXT11.xml+FIX50SP2.xml"``) loaded as a
+combined dictionary.
 """
 
 from __future__ import annotations
 
 import logging
 from dataclasses import dataclass, field
+from functools import cache
 
-from fixcore.message import load_data_dictionary
+from fixcore.message import (
+    bundled_begin_strings,
+    load_combined_data_dictionary,
+    load_data_dictionary,
+)
 from fixcore.message.data_dictionary import GroupDef
 
 logger = logging.getLogger(__name__)
 
+# The FIXT.1.1 transport spec and the default FIX 5.0 application spec used when
+# browsing a FIXT session's combined dictionary without an explicit app version.
+TRANSPORT_SPEC = "FIXT11.xml"
+DEFAULT_FIXT_APP_SPEC = "FIX50SP2.xml"
+
 
 @dataclass
 class FieldDef:
@@ -63,13 +74,42 @@ class _Spec:
 _CACHE: dict[str, _Spec] = {}
 
 
+@cache
+def _begin_string_to_spec() -> dict[str, str]:
+    """Inverse of fixcore's ``bundled_begin_strings`` — version label → spec name
+    (e.g. ``"FIX.4.2" -> "FIX42.xml"``, ``"FIXT.1.1" -> "FIXT11.xml"``)."""
+    return {ver: name for name, ver in bundled_begin_strings().items()}
+
+
+def bundled_spec_for_begin_string(begin_string: str) -> str:
+    """The bundled transport spec name for a FIX BeginString (fixcore resolves
+    it). Falls back to FIX44.xml for an unknown version."""
+    return _begin_string_to_spec().get(begin_string, "FIX44.xml")
+
+
 def spec_ref_for_version(begin_string: str) -> str:
-    """The bundled spec name for a FIX version (fixcore resolves it)."""
-    return "FIX42.xml" if "4.2" in begin_string else "FIX44.xml"
+    """The fixcore spec ref to browse for a BeginString.
+
+    FIX 4.x → its bundled single-file spec. FIXT.1.1 → a combined
+    ``transport+app`` ref (the default FIX.5.0SP2 application layer) that
+    :func:`_load_dd` resolves via ``load_combined_data_dictionary``.
+    """
+    if begin_string.startswith("FIXT"):
+        return f"{TRANSPORT_SPEC}+{DEFAULT_FIXT_APP_SPEC}"
+    return bundled_spec_for_begin_string(begin_string)
+
+
+def _load_dd(spec_ref: str):
+    """Load a DataDictionary from a spec ref. A ``transport+app`` ref (FIXT.1.1)
+    is loaded as a combined dictionary; anything else is a single spec."""
+    if "+" in spec_ref:
+        transport, app = spec_ref.split("+", 1)
+        return load_combined_data_dictionary(transport, app)
+    return load_data_dictionary(spec_ref)
 
 
 def _build_spec(spec_ref: str) -> _Spec:
-    dd = load_data_dictionary(spec_ref)
+    dd = _load_dd(spec_ref)
 
     field_defs: dict[int, FieldDef] = {
         tag: FieldDef(number=fd.number, name=fd.name, type=fd.type, values=dict(fd.values))

{fixtureqa-0.9.8 → fixtureqa-0.10.0}/fixture/core/models.py

@@ -34,8 +34,10 @@ class SessionConfig:
     session_id: str = field(default_factory=lambda: str(uuid.uuid4()))
     display_name: str = ""
 
-    # FIX identity
-    begin_string: str = "FIX.4.2"   # "FIX.4.2" or "FIX.4.4"
+    # FIX identity. Any transport-capable bundled version: "FIX.4.0".."FIX.4.4"
+    # or "FIXT.1.1" (the FIX 5.0 transport layer — pair with app_data_dictionary
+    # / default_appl_ver_id below).
+    begin_string: str = "FIX.4.2"
     sender_comp_id: str = ""
     target_comp_id: str = ""
 
@@ -62,9 +64,22 @@ class SessionConfig:
     check_latency: bool = False
     max_latency: int = 120           # MaxLatency (s): allowed SendingTime skew when check_latency
 
-    # Data dictionary (None = use bundled spec)
+    # Data dictionary (None = use bundled spec). For a FIXT.1.1 session this is
+    # ignored — the dictionary comes from the FIXT11 transport spec combined with
+    # the FIX 5.0 application spec below.
     data_dictionary_path: Optional[str] = None
 
+    # FIX 5.0 / FIXT.1.1 only. FIX 5.0 splits the spec into a frozen transport
+    # layer (FIXT11.xml) plus a versioned application dictionary; fixcore combines
+    # them (DataDictionary.combined). For a FIXT session set the application
+    # dictionary either explicitly (app_data_dictionary: a bundled name like
+    # "FIX50SP2.xml" or a custom upload's path) or implicitly via
+    # default_appl_ver_id (tag 1137: "7"=FIX.5.0, "8"=FIX.5.0SP1, "9"=FIX.5.0SP2,
+    # or a label like "FIX.5.0SP2"), which is also stamped on the outbound Logon.
+    # Ignored for non-FIXT sessions.
+    app_data_dictionary: Optional[str] = None
+    default_appl_ver_id: str = ""
+
     # Store / log paths (use per-session subdirs to avoid collisions)
     file_store_path: str = "./store"
     file_log_path: str = "./log"

{fixtureqa-0.9.8 → fixtureqa-0.10.0}/fixture/core/session.py

@@ -331,7 +331,6 @@ class Session:
     def _build_settings(self) -> SessionSettings:
         """Build fixcore SessionSettings from SessionConfig."""
         ct = "initiator" if self.config.connection_type == ConnectionType.INITIATOR else "acceptor"
-        dd_path = self._resolve_data_dictionary()
 
         store_path = os.path.abspath(
             os.path.join(self.config.file_store_path, self.config.session_id)
@@ -384,7 +383,7 @@ class Session:
             f"SendRedundantResendRequests={yn(self.config.send_redundant_resend_requests)}",
             f"EnableLastMsgSeqNumProcessed={yn(self.config.enable_last_msg_seq_num_processed)}",
             *schedule_lines,
-            f"DataDictionary={dd_path}",
+            *self._dictionary_lines(),
             # Always load the dictionary so inbound repeating groups decode into
             # proper instances (otherwise duplicate group-member tags collapse to
             # the last value). Whether non-conforming messages are *rejected* is a
@@ -420,29 +419,76 @@ class Session:
 
         return SessionSettings.from_string("\n".join(lines))
 
+    @property
+    def _is_fixt(self) -> bool:
+        """FIX 5.0 rides on a FIXT.1.1 transport — these sessions use a combined
+        transport+application dictionary rather than a single one."""
+        return self.config.begin_string.startswith("FIXT")
+
+    def _dictionary_lines(self) -> list[str]:
+        """The fixcore DataDictionary config lines for this session.
+
+        Non-FIXT: a single ``DataDictionary=`` (bundled name or custom path).
+        FIXT.1.1: ``TransportDataDictionary`` + ``AppDataDictionary`` (and the
+        negotiated ``DefaultApplVerID``), which fixcore merges into one combined
+        dictionary (see the FIX 5.0 design in fixcore). At least one of
+        AppDataDictionary / DefaultApplVerID is present (enforced on save).
+        """
+        if self._is_fixt:
+            from .fix_spec_parser import TRANSPORT_SPEC
+            lines = [f"TransportDataDictionary={TRANSPORT_SPEC}"]
+            app_ref = self._app_spec_ref()
+            if app_ref:
+                lines.append(f"AppDataDictionary={app_ref}")
+            if self.config.default_appl_ver_id:
+                lines.append(f"DefaultApplVerID={self.config.default_appl_ver_id}")
+            return lines
+        return [f"DataDictionary={self._resolve_data_dictionary()}"]
+
+    def _app_spec_ref(self) -> str:
+        """The FIX 5.0 application spec ref for a FIXT session: a custom upload's
+        absolute path, or a bundled name fixcore resolves. "" if unset (then
+        fixcore infers it from DefaultApplVerID)."""
+        val = self.config.app_data_dictionary
+        if not val:
+            return ""
+        return os.path.abspath(val) if os.path.isfile(val) else val
+
     def _resolve_data_dictionary(self) -> str:
-        """The DataDictionary value for this session — a bundled spec name that
-        fixcore resolves from its packaged dictionaries, or an absolute path to
-        a custom uploaded spec.
+        """The DataDictionary value for a non-FIXT session — a bundled spec name
+        that fixcore resolves from its packaged dictionaries, or an absolute path
+        to a custom uploaded spec.
 
         fixcore's ``load_data_dictionary`` (used by both the transport and
         :meth:`data_dictionary`) checks disk first and only then falls back to a
         bundled name, so a real file always wins.
         """
+        from .fix_spec_parser import bundled_spec_for_begin_string
         val = self.config.data_dictionary_path
         if val:
             # A custom spec is stored as an on-disk path; anything else (e.g.
             # "FIX44.xml") is a bundled spec name fixcore resolves by itself.
             return os.path.abspath(val) if os.path.isfile(val) else val
         # Default: fixcore's bundled dictionary for this session's FIX version.
-        return "FIX42.xml" if "4.2" in self.config.begin_string else "FIX44.xml"
+        return bundled_spec_for_begin_string(self.config.begin_string)
 
     def data_dictionary(self):
         """The loaded DataDictionary for this session's spec (cached by fixcore),
         or None if it can't be loaded. Used to build outbound messages with
-        correct repeating-group structure."""
-        from fixcore.message import load_data_dictionary
+        correct repeating-group structure. For FIXT.1.1 this is the combined
+        transport+application dictionary."""
+        from fixcore.message import (
+            appl_ver_id_to_spec,
+            load_combined_data_dictionary,
+            load_data_dictionary,
+        )
         try:
+            if self._is_fixt:
+                from .fix_spec_parser import TRANSPORT_SPEC
+                app = self._app_spec_ref() or appl_ver_id_to_spec(
+                    self.config.default_appl_ver_id
+                )
+                return load_combined_data_dictionary(TRANSPORT_SPEC, app)
             return load_data_dictionary(self._resolve_data_dictionary())
         except Exception:
             return None

{fixtureqa-0.9.8 → fixtureqa-0.10.0}/fixture/core/session_manager.py

@@ -262,8 +262,22 @@ class SessionManager:
             raise ValueError("sender_comp_id is required")
         if not config.target_comp_id:
             raise ValueError("target_comp_id is required")
-        if config.begin_string not in ("FIX.4.2", "FIX.4.4"):
+        from fixcore.message import appl_ver_id_to_spec, bundled_begin_strings
+        if config.begin_string not in set(bundled_begin_strings().values()):
             raise ValueError(f"Unsupported FIX version: {config.begin_string!r}")
+        # FIX 5.0 over FIXT.1.1: the transport BeginString carries no application
+        # messages, so a FIXT session needs an application dictionary — either an
+        # explicit AppDataDictionary or a DefaultApplVerID to infer it from.
+        if config.begin_string.startswith("FIXT"):
+            if not (config.app_data_dictionary or config.default_appl_ver_id):
+                raise ValueError(
+                    "A FIXT.1.1 session requires an application dictionary: set "
+                    "app_data_dictionary or default_appl_ver_id"
+                )
+            if config.default_appl_ver_id:
+                # Reject an unrecognised tag-1137 value/label up front (fixcore
+                # would otherwise only raise at engine start).
+                appl_ver_id_to_spec(config.default_appl_ver_id)
         # Schedule-combo rules (mirror fixcore so a bad combo fails on save with a
         # clear message instead of at engine start). Only meaningful when a
         # windowed schedule is in play, i.e. not non-stop.

{fixtureqa-0.9.8 → fixtureqa-0.10.0}/fixture/core/spec_store.py

@@ -6,10 +6,10 @@ Custom specs are uploaded QuickFIX-format XML files persisted at
 JSON stores, but the payload is raw XML (validated by parsing it through
 fixcore's DataDictionary before it is accepted).
 
-The bundled FIX 4.2 / 4.4 dictionaries are *not* stored here — they ship inside
-fixcore (``fixcore.message.bundled_specs()``). :func:`SpecStore.list_specs`
-returns the bundled specs alongside the user's uploaded ones so the UI can show
-one combined dropdown.
+The bundled FIX 4.0–4.4 / FIX 5.0 dictionaries are *not* stored here — they ship
+inside fixcore. :func:`SpecStore.list_specs` returns the bundled transport specs
+and FIX 5.0 application specs alongside the user's uploaded ones so the UI can
+show one combined dropdown.
 """
 
 from __future__ import annotations
@@ -18,7 +18,11 @@ import os
 import re
 import threading
 
-from fixcore.message import bundled_specs, load_data_dictionary
+from fixcore.message import (
+    bundled_app_specs,
+    bundled_begin_strings,
+    load_data_dictionary,
+)
 
 from .atomic_io import atomic_write_text
 
@@ -82,15 +86,20 @@ class SpecStore:
 
         Shape::
 
-            {"bundled": [{"name", "value", "kind": "bundled"}, ...],
+            {"bundled": [{"name", "value", "version", "kind": "bundled"}, ...],
+             "app":     [{"name", "value", "version", "kind": "app"}, ...],
              "custom":  [{"name", "value", "version", "kind": "custom"}, ...]}
 
-        ``value`` is what gets stored in ``SessionConfig.data_dictionary_path``:
-        a bare bundled name (e.g. ``"FIX44.xml"``, resolved by fixcore) for
-        bundled specs, and an absolute path for custom ones.
+        ``bundled`` are the transport-capable specs (FIX 4.x + FIXT.1.1) usable as
+        a ``DataDictionary``; ``app`` are the FIX 5.0 application dictionaries
+        usable as a FIXT session's ``AppDataDictionary``. ``value`` is what gets
+        stored on the SessionConfig: a bare bundled name (resolved by fixcore) for
+        bundled/app specs, and an absolute path for custom ones.
         """
-        bundled = [{"name": n, "value": n, "kind": "bundled"}
-                   for n in bundled_specs()]
+        bundled = [{"name": n, "value": n, "version": v, "kind": "bundled"}
+                   for n, v in bundled_begin_strings().items()]
+        app = [{"name": n, "value": n, "version": v, "kind": "app"}
+               for n, v in bundled_app_specs().items()]
         custom: list[dict] = []
         d = self._dir(uid)
         if os.path.isdir(d):
@@ -105,7 +114,7 @@ class SpecStore:
                     pass
                 custom.append({"name": fn, "value": path,
                                "version": version, "kind": "custom"})
-        return {"bundled": bundled, "custom": custom}
+        return {"bundled": bundled, "app": app, "custom": custom}
 
     def delete_spec(self, uid: str, name: str) -> bool:
         name = self._sanitize(name)