process-bigraph 1.9.0__tar.gz → 1.10.0__tar.gz

{process_bigraph-1.9.0/process_bigraph.egg-info → process_bigraph-1.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: process-bigraph
-Version: 1.9.0
+Version: 1.10.0
 Summary: protocol and execution for compositional systems biology
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -128,28 +128,44 @@ print(gather_emitter_results(composite))
 # {('emitter',): [{'level': 1.0, 'time': 0.0}, {'level': 1.5, ...}, ... {'level': 7.59, 'time': 5.0}]}
 ```
 
-**2. A draft process — a present-but-inert placeholder node.** It declares a contract
-(ports + description) but has no `update`, so a composite containing it still runs; the
-draft just no-ops. Complementary to a *site* (step 3): a draft is a node that is *there
-but inert*, a site is an empty *hole*.
+**2. A draft — an open hole whose sort is a contract.** A not-yet-implemented
+process-slot is a *hole*: an open **site** (step 3) whose `_sort` names a
+`ProcessContract` (its typed face + conditions). You design and review the topology
+with the hole in place, then fill it with any process the contract *admits*.
+`Composite` refuses to build while a required hole is open, and reports **which** hole,
+**what** contract it requires, and **which** registered processes would fill it.
 
 ```python
-from process_bigraph import DraftProcess, draft_process
-
-@draft_process(name="PTH secretion",
-    inputs={'ca_sense': 'float'}, outputs={'pth_out': 'float'},
-    contract={'summary': 'senses serum Ca, secretes PTH', 'senses': 'calcium', 'makes': 'PTH'})
-class PTHSecretion(DraftProcess):
-    pass
-
-core.register_link('PTHSecretion', PTHSecretion)
-print(PTHSecretion({}, core=core).describe())
-# DRAFT — senses serum Ca, secretes PTH  ·  makes: PTH  ·  senses: calcium  ·  status: draft - no update dynamics yet
+from bigraph_schema.contract import ProcessContract
+from process_bigraph import find_candidates, UnfilledHoleError
+
+# register the intended interface as a named contract …
+core.register_contract('PTHSecretion', ProcessContract(
+    summary='senses serum Ca, secretes PTH',
+    face={'inputs': {'ca_sense': 'float'}, 'outputs': {'pth_out': 'float'}}))
+
+# … and leave the slot as a hole sorted by it
+template = core.access({'parathyroid': {'ca': 2.5, 'pth': 0.0,
+    'secretion': {'_type': 'site', '_sort': 'PTHSecretion'}}})
+
+# Composite(..., unfilled) → UnfilledHoleError, not an opaque KeyError:
+#   not ground — required site(s) left unfilled: 'parathyroid/secretion'
+#     • parathyroid/secretion
+#         requires:
+#           inputs: ca_sense: float
+#           outputs: pth_out: float
+#         candidates:
+#           ✓ <any registered process whose contract admits the hole>
 ```
 
-A module-scope draft auto-registers, so it appears in the vivarium-workbench dashboard
-(Modules → Processes) marked **DRAFT** with its ports and contract — no code change
-needed. Replace it with a real `Process` once the mechanism is committed.
+Fill it (step 3) with a process `find_candidates(core, site)` reports as admissible,
+and build. The full design → inspect → fill → build lifecycle — and the rejection
+report in full — is in
+[docs/concepts/designing-with-holes.md](docs/concepts/designing-with-holes.md).
+
+> **Deprecated:** `@draft_process` / `DraftProcess` (an inert placeholder *node*) still
+> work but now emit `DraftProcessDeprecationWarning` — model a draft as a hole instead.
+> `draft_to_contract(cls)` bridges an existing draft's interface to a `ProcessContract`.
 
 **3. A template — a composite with an open site (hole).** A template is a document that
 isn't *ground*: it has open **sites** (`{"_type": "site"}`). `Composite` refuses to run
@@ -184,7 +200,7 @@ def model(rate):                                      # any conforming composite
 sim = Composite({'state': template_document(core, template, {'study/model': model(0.5)})}, core=core)
 sim.run(4.0)
 print(sim.state['study']['verdict'])                  # pass  (a slower model → fail)
-# template_document(core, template, {}) → ValueError: not ground — required site 'study/model'
+# template_document(core, template, {}) → UnfilledHoleError: not ground — required site 'study/model'
 ```
 
 **4. An investigation — one site per member study; gating is *filling*.** Fill a

{process_bigraph-1.9.0 → process_bigraph-1.10.0}/README.md

@@ -101,28 +101,44 @@ print(gather_emitter_results(composite))
 # {('emitter',): [{'level': 1.0, 'time': 0.0}, {'level': 1.5, ...}, ... {'level': 7.59, 'time': 5.0}]}
 ```
 
-**2. A draft process — a present-but-inert placeholder node.** It declares a contract
-(ports + description) but has no `update`, so a composite containing it still runs; the
-draft just no-ops. Complementary to a *site* (step 3): a draft is a node that is *there
-but inert*, a site is an empty *hole*.
+**2. A draft — an open hole whose sort is a contract.** A not-yet-implemented
+process-slot is a *hole*: an open **site** (step 3) whose `_sort` names a
+`ProcessContract` (its typed face + conditions). You design and review the topology
+with the hole in place, then fill it with any process the contract *admits*.
+`Composite` refuses to build while a required hole is open, and reports **which** hole,
+**what** contract it requires, and **which** registered processes would fill it.
 
 ```python
-from process_bigraph import DraftProcess, draft_process
-
-@draft_process(name="PTH secretion",
-    inputs={'ca_sense': 'float'}, outputs={'pth_out': 'float'},
-    contract={'summary': 'senses serum Ca, secretes PTH', 'senses': 'calcium', 'makes': 'PTH'})
-class PTHSecretion(DraftProcess):
-    pass
-
-core.register_link('PTHSecretion', PTHSecretion)
-print(PTHSecretion({}, core=core).describe())
-# DRAFT — senses serum Ca, secretes PTH  ·  makes: PTH  ·  senses: calcium  ·  status: draft - no update dynamics yet
+from bigraph_schema.contract import ProcessContract
+from process_bigraph import find_candidates, UnfilledHoleError
+
+# register the intended interface as a named contract …
+core.register_contract('PTHSecretion', ProcessContract(
+    summary='senses serum Ca, secretes PTH',
+    face={'inputs': {'ca_sense': 'float'}, 'outputs': {'pth_out': 'float'}}))
+
+# … and leave the slot as a hole sorted by it
+template = core.access({'parathyroid': {'ca': 2.5, 'pth': 0.0,
+    'secretion': {'_type': 'site', '_sort': 'PTHSecretion'}}})
+
+# Composite(..., unfilled) → UnfilledHoleError, not an opaque KeyError:
+#   not ground — required site(s) left unfilled: 'parathyroid/secretion'
+#     • parathyroid/secretion
+#         requires:
+#           inputs: ca_sense: float
+#           outputs: pth_out: float
+#         candidates:
+#           ✓ <any registered process whose contract admits the hole>
 ```
 
-A module-scope draft auto-registers, so it appears in the vivarium-workbench dashboard
-(Modules → Processes) marked **DRAFT** with its ports and contract — no code change
-needed. Replace it with a real `Process` once the mechanism is committed.
+Fill it (step 3) with a process `find_candidates(core, site)` reports as admissible,
+and build. The full design → inspect → fill → build lifecycle — and the rejection
+report in full — is in
+[docs/concepts/designing-with-holes.md](docs/concepts/designing-with-holes.md).
+
+> **Deprecated:** `@draft_process` / `DraftProcess` (an inert placeholder *node*) still
+> work but now emit `DraftProcessDeprecationWarning` — model a draft as a hole instead.
+> `draft_to_contract(cls)` bridges an existing draft's interface to a `ProcessContract`.
 
 **3. A template — a composite with an open site (hole).** A template is a document that
 isn't *ground*: it has open **sites** (`{"_type": "site"}`). `Composite` refuses to run
@@ -157,7 +173,7 @@ def model(rate):                                      # any conforming composite
 sim = Composite({'state': template_document(core, template, {'study/model': model(0.5)})}, core=core)
 sim.run(4.0)
 print(sim.state['study']['verdict'])                  # pass  (a slower model → fail)
-# template_document(core, template, {}) → ValueError: not ground — required site 'study/model'
+# template_document(core, template, {}) → UnfilledHoleError: not ground — required site 'study/model'
 ```
 
 **4. An investigation — one site per member study; gating is *filling*.** Fill a

{process_bigraph-1.9.0 → process_bigraph-1.10.0}/process_bigraph/__init__.py

@@ -14,6 +14,35 @@ def allocate_core(*args, strict=False, **kwargs):
     """
     core = _allocate_core(*args, **kwargs)
     core.strict_config = bool(strict)
+    _register_builtin_emitters(core)
+    return core
+
+
+def _register_builtin_emitters(core):
+    """Ensure process-bigraph's built-in emitters are registered under their
+    SHORT names (``RAMEmitter`` etc.), not only their fully-qualified names.
+
+    Discovery normally registers both, but when several emitter packages
+    co-register in an unlucky import order the short alias is silently dropped
+    (see ``process_bigraph.emitter._VIVA_REEXPORTS``) — leaving only the FQN
+    ``process_bigraph.emitter.RAMEmitter`` and breaking the framework's own
+    default sink ``local:RAMEmitter``. Registering the built-ins explicitly here
+    is order-independent and idempotent (we only fill a missing short alias).
+    """
+    try:
+        from process_bigraph.emitter import (
+            Emitter, ConsoleEmitter, RAMEmitter, JSONEmitter)
+    except Exception:
+        return
+    registry = getattr(core, 'link_registry', None)
+    for cls in (Emitter, ConsoleEmitter, RAMEmitter, JSONEmitter):
+        name = cls.__name__
+        if registry is not None and name in registry:
+            continue
+        try:
+            core.register_link(name, cls)
+        except Exception:
+            pass
     return core
 
 # The installed distribution's version, exposed so a run manifest can record
@@ -41,7 +70,16 @@ from process_bigraph.composite_spec import (  # noqa: F401
     normalize_type, CANONICAL_TYPES,
 )
 from process_bigraph.bundle import load_bundle  # noqa: F401
-from process_bigraph.draft_process import DraftProcess, draft_process  # noqa: F401
+from process_bigraph.draft_process import (  # noqa: F401
+    DraftProcess, draft_process, draft_to_contract, DraftProcessDeprecationWarning,
+)
+# Holes-in-place: the public lifecycle for a process-slot left as a hole whose
+# sort is a ProcessContract — design, inspect, see what fits, fill, build.
+from process_bigraph.holes import UnfilledHoleError  # noqa: F401
+from process_bigraph.templates import (  # noqa: F401
+    open_sites, required_open_sites, is_ground_document, fill_template, template_document,
+)
+from bigraph_schema.matching import find_candidates  # noqa: F401
 from process_bigraph.emitter import Emitter, gather_emitter_results, generate_emitter_state  # noqa: F401
 from process_bigraph.types import StepLink, ProcessLink, CompositeLink  # noqa: F401
 from process_bigraph import core_introspection  # noqa: F401

{process_bigraph-1.9.0 → process_bigraph-1.10.0}/process_bigraph/composite.py

@@ -1264,6 +1264,7 @@ class Composite(Process):
         'parallel_steps': 'boolean{false}',
         # Runtime contract checking: off (default, zero-cost) | record | raise.
         'contract_strict': 'string{off}',
+        'orchestration': 'string{temporal}',
         # Time-scheduled processes: when True, the per-tick `run` loop
         # fans out invocations across a thread pool. Right tool when
         # processes' update() releases the GIL (network I/O, numpy /
@@ -2384,13 +2385,16 @@ class Composite(Process):
         # Build the step execution dependency graph
         self.step_dependencies, self.node_dependencies = build_step_network(self.step_paths)
 
-        # Reject dependency cycles among zero-time steps. The paper
-        # (Supplement 1, 3.8.4) guarantees the step network is a DAG:
-        # "Cycles are disallowed, ensuring deterministic zero-time DAG
-        # evaluation." A cycle has no valid evaluation order, so the
-        # scheduler would otherwise fall back to a hash-seed-dependent
-        # tie-break and the same document would give different results in
-        # different processes (issue #233).
+        # Reject only NON-DETERMINISTIC dependency cycles among zero-time
+        # steps. The paper (Supplement 1, 3.8.4) guarantees the step network
+        # is a DAG, but in practice ``determine_steps`` resolves a cycle by
+        # firing the highest-priority runnable step first: that is
+        # deterministic when the cyclic steps carry distinct priorities, and
+        # ``find_step_cycle`` allows those (with a warning). It returns a
+        # cycle here only when two of its members share a priority, so the
+        # tie would fall through to a hash-seed-dependent order and the same
+        # document would give different results in different processes
+        # (issue #233).
         cycle = find_step_cycle(self.step_dependencies, self.node_dependencies)
         if cycle is not None:
             def _name(step_key):
@@ -2399,13 +2403,16 @@ class Composite(Process):
                 return str(step_key)
             rendered = ' -> '.join(_name(step_key) for step_key in cycle)
             raise ValueError(
-                f'step dependency cycle detected: {rendered}. '
-                f'Steps evaluate in zero time as a DAG, so a cycle has no '
-                f'deterministic evaluation order (process-bigraph paper, '
-                f'Supplement 1, 3.8.4). Break the cycle by removing one of '
-                f'the mutual input/output wirings between these steps, or '
-                f'model the feedback as a Process with a non-zero time '
-                f'interval.')
+                f'non-deterministic step dependency cycle detected: '
+                f'{rendered}. These steps form a zero-time feedback cycle AND '
+                f'share a priority, so their evaluation order would depend on '
+                f'PYTHONHASHSEED-driven set-iteration order and differ between '
+                f'processes (process-bigraph paper, Supplement 1, 3.8.4; '
+                f'issue #233). Resolve it by giving the cyclic steps '
+                f'distinct priorities (the scheduler then orders them '
+                f'deterministically), removing one of the mutual input/output '
+                f'wirings, or modelling the feedback as a Process with a '
+                f'non-zero time interval.')
 
         # Initialize trigger fulfillment state and steps remaining
         self.reset_step_state(self.step_paths)
@@ -2728,7 +2735,7 @@ class Composite(Process):
         # control flows on the same thread.
         _cc_token = current_composite_var.set(self)
         try:
-            return self._run_inner(interval, force_complete, run_start)
+            return self._orchestration_strategy().advance(interval, force_complete, run_start)
         except BaseException as exc:
             status, error = 'error', f'{type(exc).__name__}: {exc}'
             raise
@@ -2775,101 +2782,101 @@ class Composite(Process):
                 if span is not None:
                     span.end(status, error)
 
-    def _run_inner(self, interval: float, force_complete: bool,
-                   run_start: float) -> None:
-        end_time = self.state['global_time'] + interval
-
-        # Run any steps that are ready (from init or previous triggers)
+    def _orchestration_strategy(self):
+        """Resolve (and cache) this Composite's orchestration strategy from the
+        registry. Defaults to ``temporal`` — the event-scheduling loop in
+        :meth:`advance_tick` — so a Composite that declares no ``orchestration``
+        runs exactly as before."""
+        strat = getattr(self, "_orchestration", None)
+        if strat is None:
+            from process_bigraph.orchestration import get_orchestration
+            name = self.config.get("orchestration") or "temporal"
+            strat = self._orchestration = get_orchestration(name)(self)
+        return strat
+
+    def run_step_network(self) -> None:
+        """Drain the ready-step DAG to completion: ``run_steps`` self-cascades
+        through ``cycle_step_state``/``trigger_steps``, so this runs every
+        currently-ready step in dependency order. The step-DAG primitive shared
+        by the temporal and workflow orchestration strategies."""
         if self.to_run:
             self.run_steps(self.to_run)
             self.to_run = []
 
-        em = self._em
-        while self.state['global_time'] < end_time or force_complete:
-            full_step = math.inf
-            self._run_ticks = getattr(self, '_run_ticks', 0) + 1
-            em.heartbeat(global_time=self.state['global_time'])
-
-            # Partition processes: ones whose runtime opts into batched
-            # tick_lifecycle vs the regular per-process path. The
-            # runtime-managed group(s) get one method call per runtime,
-            # which (a) skips N _cached_view + N invoke calls in this
-            # tick's invoke pass, and (b) returns one combined Defer that
-            # apply_updates walks once instead of N times.
-            managed_paths, runtime_groups = self._partition_processes_by_runtime()
-
-            # Run each plain (non-runtime-managed) process and compute the
-            # minimum time step that advances simulation.
-            if self._parallel_processes and len(self.process_paths) > 1:
-                full_step = self._run_processes_layer_parallel(
-                    end_time, full_step, force_complete,
-                    skip_paths=managed_paths)
-            else:
-                for path in self.process_paths:
-                    if path in managed_paths:
-                        continue
-                    process = get_path(self.state, path)
-                    full_step = self.run_process(
-                        path, process, end_time, full_step, force_complete)
-
-            # Now dispatch each runtime group via its tick_lifecycle hook.
-            # Each call returns one combined Defer (placed at a common-path
-            # slot in self.front) so the downstream apply_updates walks
-            # the schema once for the entire batch.
-            for rt, group in runtime_groups:
-                full_step = self._run_tick_lifecycle(
-                    rt, group, end_time, full_step, force_complete)
-
-            if full_step == math.inf:
-                # No process ran — jump to the next scheduled process time
-                next_event = end_time
-                for path in self.front.keys():
-                    if self.front[path]['time'] < next_event:
-                        next_event = self.front[path]['time']
-                self.state['global_time'] = next_event
-
-            elif self.state['global_time'] + full_step <= end_time:
-                # At least one process ran — advance time and apply its update
-                self.state['global_time'] += full_step
-                updates = []
-                paths = []
-
-                for path, advance in self.front.items():
-                    if advance['time'] <= self.state['global_time'] and advance['update']:
-                        updates.append(advance['update'])
-                        advance['update'] = {}
-                        paths.append(path)
-
-                fw_start = _time.monotonic()
-                self._flush_protocol_runtimes()
-                update_paths = self.apply_updates(updates)
-                update_paths.append(('global_time',)) # updated global time can trigger steps
-                self.expire_process_paths(update_paths)
-                self.steps_run = set()  # Reset for new timestep
-                # Opt-in halt after structural change. EcoliSim sets
-                # ``_halt_after_structural=True`` to mirror v1's halt
-                # via DivisionDetected. Dynamic-structure tests leave
-                # the flag unset for natural cascading.
-                if (getattr(self, '_halt_after_structural', False)
-                        and getattr(self, '_last_apply_structural', False)):
-                    self.framework_time += _time.monotonic() - fw_start
-                    return
-                self.trigger_steps(update_paths)
+    def advance_tick(self, end_time: float, force_complete: bool):
+        """Execute ONE temporal tick toward ``end_time`` — the body of the
+        event-scheduling loop. Returns ``(halted, force_complete)``: ``halted``
+        is True when an opt-in structural halt fired and the run must stop now;
+        ``force_complete`` is returned because the tick may clear it. The
+        ``temporal`` strategy drives this in a loop while ``Composite`` owns the
+        tick mechanics (front, invoke, apply), keeping strategies thin."""
+        full_step = math.inf
+        self._run_ticks = getattr(self, '_run_ticks', 0) + 1
+        self._em.heartbeat(global_time=self.state['global_time'])
+
+        # Partition processes: runtime-batched (tick_lifecycle) vs per-process.
+        managed_paths, runtime_groups = self._partition_processes_by_runtime()
+
+        if self._parallel_processes and len(self.process_paths) > 1:
+            full_step = self._run_processes_layer_parallel(
+                end_time, full_step, force_complete,
+                skip_paths=managed_paths)
+        else:
+            for path in self.process_paths:
+                if path in managed_paths:
+                    continue
+                process = get_path(self.state, path)
+                full_step = self.run_process(
+                    path, process, end_time, full_step, force_complete)
+
+        for rt, group in runtime_groups:
+            full_step = self._run_tick_lifecycle(
+                rt, group, end_time, full_step, force_complete)
+
+        if full_step == math.inf:
+            # No process ran — jump to the next scheduled process time
+            next_event = end_time
+            for path in self.front.keys():
+                if self.front[path]['time'] < next_event:
+                    next_event = self.front[path]['time']
+            self.state['global_time'] = next_event
+
+        elif self.state['global_time'] + full_step <= end_time:
+            # At least one process ran — advance time and apply its update
+            self.state['global_time'] += full_step
+            updates = []
+            paths = []
+
+            for path, advance in self.front.items():
+                if advance['time'] <= self.state['global_time'] and advance['update']:
+                    updates.append(advance['update'])
+                    advance['update'] = {}
+                    paths.append(path)
+
+            fw_start = _time.monotonic()
+            self._flush_protocol_runtimes()
+            update_paths = self.apply_updates(updates)
+            update_paths.append(('global_time',))  # updated global time can trigger steps
+            self.expire_process_paths(update_paths)
+            self.steps_run = set()  # Reset for new timestep
+            # Opt-in halt after structural change (EcoliSim parity). On halt the
+            # run stops immediately, skipping the post-loop bookkeeping — the
+            # driving loop returns without finalizing framework_time.
+            if (getattr(self, '_halt_after_structural', False)
+                    and getattr(self, '_last_apply_structural', False)):
                 self.framework_time += _time.monotonic() - fw_start
+                return True, force_complete
+            self.trigger_steps(update_paths)
+            self.framework_time += _time.monotonic() - fw_start
 
-            else:
-                # All remaining process events are beyond end_time
-                self.state['global_time'] = end_time
+        else:
+            # All remaining process events are beyond end_time
+            self.state['global_time'] = end_time
 
-            if force_complete and self.state['global_time'] == end_time:
-                force_complete = False
+        if force_complete and self.state['global_time'] == end_time:
+            force_complete = False
 
-        total = _time.monotonic() - run_start
-        # Framework time = total minus process update time
-        # (the process_update_time was accumulated in process_update and,
-        # for batched-runtime processes, in _run_tick_lifecycle)
-        self.framework_time = total - self.process_update_time
-        self._last_run_total_time = total
+        return False, force_complete
 
     def timing_summary(self) -> TimingSummary:
         """Return a ``TimingSummary`` describing the most recent ``run()`` call.
@@ -2899,15 +2906,20 @@ class Composite(Process):
             per_process=dict(self._per_process_time),
         )
 
-    @staticmethod
-    def _raise_not_ground(unfilled) -> None:
-        """Raise the shared "not ground" error naming the open site paths."""
-        named = ', '.join(repr('/'.join(path)) for path in unfilled)
-        raise ValueError(
-            f'composite document is not ground — required site(s) left '
-            f'unfilled: {named}. An open site is a hole where a process '
-            f'or value should be; fill it before constructing the '
-            f'composite (bigraph_schema `fill_sites` / `build`).')
+    def _raise_unfilled(self, unfilled_pairs) -> None:
+        """Raise a contract-aware :class:`~process_bigraph.holes.UnfilledHoleError`
+        for the open ``(path, site)`` pairs.
+
+        Names each hole's required contract (typed face + conditions) and the
+        registered processes that would fill it, in place of the opaque
+        ``KeyError: 'data'`` an unfilled address site would otherwise raise deep
+        in realization. The error subclasses ``ValueError``, so existing
+        ``except ValueError`` callers keep catching it, and its message keeps the
+        "not ground — required site(s) left unfilled" lineage.
+        """
+        from process_bigraph.holes import build_unfilled_hole_error
+        ordered = sorted(unfilled_pairs, key=lambda pair: pair[0])
+        raise build_unfilled_hole_error(self.core, ordered)
 
     def _require_ground_input(
             self,
@@ -2944,10 +2956,12 @@ class Composite(Process):
             # A site is a state-level hole: inspect the document as written,
             # so a declared `schema` type cannot hide a `state` site.
             accessed = self.core.access(initial_state)
-            unfilled = sorted({
-                tuple(path)
-                for path, site in interfaces(accessed)[0]._places
-                if getattr(site, '_default', None) is None})
+            # Keep one (path, site) per unique path; collect_sites/interfaces may
+            # address a site more than once.
+            unfilled = {}
+            for path, site in interfaces(accessed)[0]._places:
+                if getattr(site, '_default', None) is None:
+                    unfilled.setdefault(tuple(path), site)
         except Exception:
             # If the raw document cannot be inspected for any reason, do not
             # mask that behind this check — fall through to realization and
@@ -2955,7 +2969,7 @@ class Composite(Process):
             return
 
         if unfilled:
-            self._raise_not_ground(unfilled)
+            self._raise_unfilled(list(unfilled.items()))
 
     def _require_ground_document(self) -> None:
         """Reject a document that still has unfilled template holes.
@@ -2979,14 +2993,14 @@ class Composite(Process):
         from bigraph_schema.assembly import collect_sites
 
         # ``collect_sites`` addresses each site twice (bare key and path);
-        # collapse to unique paths.
-        unfilled = sorted({
-            tuple(path)
-            for path, site in collect_sites(self.schema).values()
-            if getattr(site, '_default', None) is None})
+        # collapse to one (path, site) per unique path.
+        unfilled = {}
+        for path, site in collect_sites(self.schema).values():
+            if getattr(site, '_default', None) is None:
+                unfilled.setdefault(tuple(path), site)
 
         if unfilled:
-            self._raise_not_ground(unfilled)
+            self._raise_unfilled(list(unfilled.items()))
 
     def _require_advancing_interval(
             self,

{process_bigraph-1.9.0 → process_bigraph-1.10.0}/process_bigraph/composite_discovery.py

@@ -83,8 +83,10 @@ def discover_all(
 
     Spec entries get ``kind: spec`` and pass through the existing spec
     payload. Generator entries get ``kind: generator`` and a compact dict
-    {name, description, parameters, module} so dashboards can render them
-    without holding a reference to the live function object.
+    {name, description, parameters, visualizations, emitters, module,
+    default_n_steps, methods, fidelity} so dashboards can render them (and
+    report their modeling provenance) without holding a reference to the live
+    function object.
 
     Discovery imports the host packages of every generator (see
     :func:`process_bigraph.composite_generator.discover_generators`). If
@@ -118,6 +120,12 @@ def discover_all(
             "emitters": list(entry.emitters),
             "module": entry.module,
             "default_n_steps": entry.default_n_steps,
+            # Modeling-provenance metadata — so a consumer that only sees this
+            # serialized dict (e.g. a dashboard across a worker boundary) can
+            # still report how the composite is built and whether it wraps a
+            # genuine simulator. Always present (empty list / "" when undeclared).
+            "methods": list(getattr(entry, "methods", []) or []),
+            "fidelity": getattr(entry, "fidelity", "") or "",
         }
     return out