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

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

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: process-bigraph
-Version: 1.8.5
+Version: 1.9.0
 Summary: protocol and execution for compositional systems biology
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: AUTHORS.md
-Requires-Dist: bigraph-schema>=1.6.0
+Requires-Dist: bigraph-schema>=1.8.1
 Requires-Dist: requests>=2.31
 Requires-Dist: matplotlib
 Requires-Dist: pint>=0.24.4
@@ -119,7 +119,8 @@ core.register_link('Grow', Grow)                      # register it in the local
 composite = Composite({'state': {
     'level': 1.0,                                     # a shared store
     'grow': {'_type': 'process', 'address': 'local:Grow', 'config': {'rate': 0.5},
-             'interval': 1.0, 'inputs': {'level': ['level']}, 'outputs': {'level': ['level']}},
+             'interval': 1.0,                         # seconds; a unit string like '1 min' also works
+             'inputs': {'level': ['level']}, 'outputs': {'level': ['level']}},
     'emitter': emitter_from_wires({'level': ['level'], 'time': ['global_time']}),
 }}, core=core)
 composite.run(5.0)
@@ -234,7 +235,8 @@ rendered to HTML and published automatically on GitHub Pages.
 
 - **Tutorial 3 — Declarative Math**  
   *Defining mathematical relationships, signal pipelines, and events using `MathExpressionStep`*  
-  https://vivarium-collective.github.io/process-bigraph/notebooks/tutorial_3.html
+  https://vivarium-collective.github.io/process-bigraph/notebooks/tutorial_3.html  
+  Requires the companion package [`viva-basic-processes`](https://github.com/vivarium-collective/viva-basic-processes), published to PyPI as `pbg-basic-processes` (`pip install "pbg-basic-processes[plotting]>=0.3.0"`), which provides `MathExpressionStep`, the `Tick` process, and the plotting helpers.
 
 - **Tutorial 4 — Composing a Biological Model**  
   *The central dogma from four small processes: composition over shared molecular state, biological units in the port types, and adding regulation by adding a wire*  

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

@@ -92,7 +92,8 @@ core.register_link('Grow', Grow)                      # register it in the local
 composite = Composite({'state': {
     'level': 1.0,                                     # a shared store
     'grow': {'_type': 'process', 'address': 'local:Grow', 'config': {'rate': 0.5},
-             'interval': 1.0, 'inputs': {'level': ['level']}, 'outputs': {'level': ['level']}},
+             'interval': 1.0,                         # seconds; a unit string like '1 min' also works
+             'inputs': {'level': ['level']}, 'outputs': {'level': ['level']}},
     'emitter': emitter_from_wires({'level': ['level'], 'time': ['global_time']}),
 }}, core=core)
 composite.run(5.0)
@@ -207,7 +208,8 @@ rendered to HTML and published automatically on GitHub Pages.
 
 - **Tutorial 3 — Declarative Math**  
   *Defining mathematical relationships, signal pipelines, and events using `MathExpressionStep`*  
-  https://vivarium-collective.github.io/process-bigraph/notebooks/tutorial_3.html
+  https://vivarium-collective.github.io/process-bigraph/notebooks/tutorial_3.html  
+  Requires the companion package [`viva-basic-processes`](https://github.com/vivarium-collective/viva-basic-processes), published to PyPI as `pbg-basic-processes` (`pip install "pbg-basic-processes[plotting]>=0.3.0"`), which provides `MathExpressionStep`, the `Tick` process, and the plotting helpers.
 
 - **Tutorial 4 — Composing a Biological Model**  
   *The central dogma from four small processes: composition over shared molecular state, biological units in the port types, and adding regulation by adding a wire*  

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

@@ -1,4 +1,20 @@
-from bigraph_schema import allocate_core  # noqa: F401
+from bigraph_schema import allocate_core as _allocate_core
+
+
+def allocate_core(*args, strict=False, **kwargs):
+    """Allocate a core (see :func:`bigraph_schema.allocate_core`).
+
+    Adds process-bigraph's opt-in strict-config mode (issue #232): with
+    ``strict=True`` the returned core carries ``strict_config = True``, so
+    instantiating a Process/Step with a config key that is not declared in
+    its ``config_schema`` raises a clear error instead of silently ignoring
+    the key. The default (``strict=False``) preserves existing behavior
+    exactly. You can also toggle it on an existing core with
+    ``core.strict_config = True``.
+    """
+    core = _allocate_core(*args, **kwargs)
+    core.strict_config = bool(strict)
+    return core
 
 # The installed distribution's version, exposed so a run manifest can record
 # *which* engine produced an artifact. Read from installed metadata rather

process_bigraph-1.9.0/process_bigraph/audit_contracts.py

@@ -0,0 +1,128 @@
+"""CI audit gate for declared process contracts (spec section 5).
+
+Audits every registered process's DECLARED contract (static — no instantiation)
+and fails (exit 1) on any error-severity finding, or on a declared-coverage
+floor. Read the class `.contract` directly (contract_of drops amendments). In
+process-bigraph's own CI few processes declare contracts, so the error-gate is
+largely a regression guard; the real value is downstream workspaces running
+`python -m process_bigraph.audit_contracts` against their registries, and the
+--require-declared floor makes coverage visible.
+"""
+import argparse
+import json as _json
+import sys
+
+try:
+    from bigraph_schema.contract_audit import audit_contract, completeness
+    from bigraph_schema.assembly import contract_of
+    from bigraph_schema.contract import resolve_contract
+    AUDIT_AVAILABLE = True
+except Exception:  # noqa: BLE001
+    AUDIT_AVAILABLE = False
+
+from process_bigraph import allocate_core
+
+_INCOMPLETE_BELOW = 0.5
+
+
+def _class_key(cls):
+    return f'{getattr(cls, "__module__", "?")}.{getattr(cls, "__qualname__", getattr(cls, "__name__", "?"))}'
+
+
+def _contract_for(core, address, cls):
+    """Declared contract of a class, amendments preserved. Reads the class
+    `.contract` first (contract_of drops amendments), then falls back."""
+    declared = getattr(cls, 'contract', None)
+    if declared is not None:
+        try:
+            return resolve_contract(cls)   # normalizes ProcessContract/dict; never raises
+        except Exception:  # noqa: BLE001
+            pass
+    try:
+        return contract_of(core, address)
+    except Exception:  # noqa: BLE001
+        return None
+
+
+def audit_all(core, *, require_declared=0, strict_resolve=False):
+    from process_bigraph.core_introspection import list_processes
+    reports = {}
+    for address in list_processes(core):
+        try:
+            cls = core.link_registry.get(address)
+        except Exception:  # noqa: BLE001 - per-entry import failure
+            cls = None
+        if cls is None:
+            reports.setdefault(f'unresolvable:{address}',
+                               {'address': address, 'cls': address, 'status': 'unresolvable',
+                                'grade': None, 'findings': [], 'declared': False})
+            continue
+        key = _class_key(cls)
+        if key in reports:
+            continue   # alias dedup
+        contract = _contract_for(core, address, cls)
+        if contract is None:
+            reports[key] = {'address': address, 'cls': key, 'status': 'not-declared', 'grade': None, 'findings': [], 'declared': False}
+            continue
+        try:
+            report = audit_contract(core, contract)
+            grade = completeness(contract)
+            findings = [{'severity': f.severity, 'code': f.code, 'where': f.where, 'message': f.message}
+                        for f in report.findings]
+        except Exception as error:  # noqa: BLE001
+            reports[key] = {'address': address, 'cls': key, 'status': 'unresolvable', 'grade': None,
+                            'findings': [{'severity': 'error', 'code': 'audit_raised', 'where': key, 'message': str(error)}], 'declared': False}
+            continue
+        has_contract_attr = getattr(cls, 'contract', None) is not None
+        is_declared = has_contract_attr or bool(contract.conditions())
+        if any(f['severity'] == 'error' for f in findings):
+            status = 'fail'
+        elif not is_declared:
+            status = 'not-declared'
+        elif grade < _INCOMPLETE_BELOW:
+            status = 'incomplete'
+        else:
+            status = 'pass'
+        reports[key] = {'address': address, 'cls': key, 'status': status, 'grade': round(grade, 3), 'findings': findings, 'declared': is_declared}
+
+    rows = list(reports.values())
+    errors = sum(1 for r in rows for f in r['findings'] if f['severity'] == 'error')
+    if strict_resolve:
+        errors += sum(1 for r in rows if r['status'] == 'unresolvable')
+    declared_count = sum(1 for r in rows if r.get('declared'))
+    exit_code = 1 if (errors > 0 or (require_declared > 0 and declared_count < require_declared)) else 0
+    return {'reports': rows, 'declared': declared_count, 'errors': errors, 'exit_code': exit_code}
+
+
+def _build_parser():
+    p = argparse.ArgumentParser(prog='python -m process_bigraph.audit_contracts',
+                                description='Audit registered process contracts; exit 1 on any error finding.')
+    p.add_argument('--require-declared', type=int, default=0, metavar='N',
+                   help='fail if fewer than N processes declare a real contract (default 0 = off).')
+    p.add_argument('--strict-resolve', action='store_true', help='treat unresolvable processes as failures.')
+    p.add_argument('--json', action='store_true', help='emit the full report as JSON.')
+    return p
+
+
+def main(argv=None):
+    args = _build_parser().parse_args(argv)
+    if not AUDIT_AVAILABLE:
+        print('contract audit unavailable: bigraph-schema >= 1.7.0 required', file=sys.stderr)
+        return 2
+    core = allocate_core()
+    result = audit_all(core, require_declared=args.require_declared, strict_resolve=args.strict_resolve)
+    if args.json:
+        print(_json.dumps(result, indent=2))
+        return result['exit_code']
+    for r in sorted(result['reports'], key=lambda x: (x['status'] != 'fail', x['cls'])):
+        grade = '' if r['grade'] is None else f" {int(r['grade'] * 100)}%"
+        print(f"{r['status']:13} {r['cls']}{grade}")
+        for f in r['findings']:
+            print(f"    {f['severity']} {f['code']} {f['where']}: {f['message']}")
+    print(f"\n{result['declared']} declared, {result['errors']} error finding(s) "
+          f"-> {'FAIL' if result['exit_code'] else 'OK'}")
+    return result['exit_code']
+
+
+if __name__ == '__main__':
+    sys.exit(main())

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

@@ -76,6 +76,7 @@ from process_bigraph.scheduling import (  # noqa: F401
     build_trigger_state,
     find_downstream,
     determine_steps,
+    find_step_cycle,
 )
 
 
@@ -312,6 +313,36 @@ def interval_time_precision(timestep: float) -> int:
 # Process Classes
 # ===============
 
+def validate_config_keys(instance, config, core):
+    """Reject config keys not declared in ``config_schema`` when strict mode is on.
+
+    Opt-in "strict config" mode (issue #232). By default a Process/Step
+    silently ignores config keys that aren't part of its ``config_schema``,
+    so a typo'd or unsupported key passes unnoticed. When the core carries
+    ``strict_config`` truthy (set it directly or via
+    :func:`process_bigraph.allocate_core(strict=True)`), any such undeclared
+    key raises a clear :class:`ValueError` naming the offending key(s) and the
+    process type.
+
+    This is a no-op when ``strict_config`` is falsy/absent on the core, so the
+    default behavior of every existing workspace is unchanged.
+    """
+    if config is None or core is None:
+        return
+    if not getattr(core, 'strict_config', False):
+        return
+    declared = set((getattr(instance, 'config_schema', None) or {}).keys())
+    unknown = [key for key in config if key not in declared]
+    if unknown:
+        type_name = type(instance).__name__
+        raise ValueError(
+            f"{type_name} received unknown config key(s) {sorted(unknown)!r} "
+            f"that are not declared in its config_schema "
+            f"(declared keys: {sorted(declared)!r}). Strict-config mode is on "
+            f"(core.strict_config is set / allocate_core(strict=True)); pass "
+            f"only declared keys, fix the typo, or disable strict mode.")
+
+
 class SyncUpdate:
     """
     Wrapper for synchronous process updates.
@@ -348,6 +379,11 @@ class Open(Edge):
         self._pending_command: Optional[
             Tuple[str, Optional[tuple], Optional[dict]]] = None
 
+        # Opt-in strict-config check (issue #232): reject undeclared config
+        # keys before the edge fills/initializes. No-op unless the core has
+        # strict_config set, so default behavior is unchanged.
+        validate_config_keys(self, config, core)
+
         super().__init__(config, core=core)
 
     def pre_send_command(
@@ -1148,6 +1184,17 @@ def _project_process_update(update_results: Any, args: Tuple[Any, str, Any]) ->
     to the previous per-call closure.
     """
     composite, ports_key, process_path = args
+    strict = getattr(composite, '_contract_strict', 'off')
+    if strict != 'off':
+        # v1: only a dict delta is post-checked; list-form (multi-update) is left unchecked.
+        compiled = composite._compiled_contracts.get(process_path)
+        if compiled is not None and isinstance(update_results, dict):
+            from process_bigraph.contract_strict import check_post, handle_violations
+            inputs = composite._cached_view(process_path)
+            fails = check_post(compiled, inputs, update_results)
+            handle_violations(fails, mode=strict, phase='post', path=process_path,
+                              cls='process', emitter=composite._em,
+                              global_time=composite.state.get('global_time', 0.0) if isinstance(composite.state, dict) else 0.0)
     if not isinstance(update_results, list):
         update_results = [update_results]
     return [
@@ -1215,6 +1262,8 @@ class Composite(Process):
         # step hot path releases the GIL (numpy / scipy / numba / C
         # extensions: yes; pure-Python loops: no).
         'parallel_steps': 'boolean{false}',
+        # Runtime contract checking: off (default, zero-cost) | record | raise.
+        'contract_strict': 'string{off}',
         # 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 /
@@ -1279,6 +1328,16 @@ class Composite(Process):
         if 'global_time' not in initial_state:
             initial_state['global_time'] = 0.0
 
+        # Reject open template holes BEFORE realizing, over the document as
+        # given. Realization cannot cope with a site where it expects a type
+        # or an address: a declared `schema` entry silently swallows a `state`
+        # site (it realizes the declared type and drops the hole, so the
+        # composite runs on the type default with no error — case A), and an
+        # open `address` site crashes deep in `realize_link` with an opaque
+        # `KeyError: 'data'` (case B). Checking the raw document first turns
+        # both into the same clear "not ground" error that names the site.
+        self._require_ground_input(initial_schema, initial_state)
+
         # Generate internal schema and state structures using the core engine.
         # Top-level realize: realize_root defaults to () so no merges escape.
         self.schema, self.state, _ = self.core.realize(
@@ -1423,6 +1482,8 @@ class Composite(Process):
         # field in interface_schema for the rationale (threading vs.
         # multiprocessing for inner parallelism).
         self._parallel_steps = bool(self.config.get('parallel_steps', False))
+        self._contract_strict = self.config.get('contract_strict') or getattr(self.core, 'contract_strict', 'off')
+        self._compiled_contracts = {}
         self._parallel_processes = bool(self.config.get('parallel_processes', False))
         self._parallel_workers = self.config.get('parallel_workers')
         self._step_executor = None  # lazy: created on first run_steps need
@@ -1916,16 +1977,27 @@ class Composite(Process):
         path for any path not present.
         """
         self._compiled_links = {}
+        self._compiled_contracts = {}
 
         for path in list(self.process_paths) + list(self.step_paths):
             compiled = self.core.precompile_link(
                 self.schema, self.state, path)
             if compiled is not None:
                 self._compiled_links[path] = compiled
+            if self._contract_strict != 'off':
+                try:
+                    from process_bigraph.contract_strict import compile_contract
+                    node = self.state
+                    for key in path:
+                        node = node[key]
+                    self._compiled_contracts[path] = compile_contract(node['instance'].describe_contract())
+                except Exception:  # noqa: BLE001 - a process without a readable contract is simply unchecked
+                    self._compiled_contracts[path] = None
 
     def _invalidate_caches(self) -> None:
         """Invalidate precompiled link caches, forcing rebuild on next use."""
         self._compiled_links = {}
+        self._compiled_contracts = {}
         self._runtime_partition_cache = None
 
     def _cached_view(self, path: Tuple[str, ...]) -> Dict[str, Any]:
@@ -2312,6 +2384,29 @@ 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).
+        cycle = find_step_cycle(self.step_dependencies, self.node_dependencies)
+        if cycle is not None:
+            def _name(step_key):
+                if isinstance(step_key, (tuple, list)):
+                    return '/'.join(str(part) for part in step_key)
+                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.')
+
         # Initialize trigger fulfillment state and steps remaining
         self.reset_step_state(self.step_paths)
 
@@ -2569,6 +2664,27 @@ class Composite(Process):
         incrementally based on their configured interval. Updates are applied and
         steps are triggered accordingly.
 
+        Update-timing contract (matters only when intervals are unequal)
+        ----------------------------------------------------------------
+        A process reads its input ports from the shared state **at the start of
+        its interval** (the moment it becomes due), computes its update right
+        then, and the delta is applied when ``global_time`` reaches
+        ``due_time + interval`` — the "stash" model (Supplement 1, §3.8.6).
+        This is **not** the idealized read-at-event-time ``t*`` rule of
+        Supplement 1, §3.8.2: the two agree when every process shares one
+        interval and diverge otherwise, because a slow process applies a delta
+        computed from inputs as they stood one interval earlier. See
+        :meth:`run_process` and ``docs/concepts/composites-and-templates.md``
+        ("Update timing with unequal intervals").
+
+        Chunking caveat: the read-at-start guarantee holds only for a process
+        whose whole next interval fits inside this ``run`` call. A process whose
+        next due time falls past ``global_time + interval`` is deferred to the
+        next ``run`` call and re-reads its inputs there, so ``run(T)`` once can
+        differ from several shorter ``run`` calls over the same span. For
+        chunking-invariant results, pass an ``interval`` at least as large as the
+        largest process interval, or keep intervals equal.
+
         After completion, ``self.process_update_time`` holds the cumulative time
         spent inside process ``invoke()`` calls, and ``self.framework_time`` holds
         the time spent in framework operations (view, project, apply, realize).
@@ -2783,6 +2899,64 @@ 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 _require_ground_input(
+            self,
+            initial_schema: Dict[str, Any],
+            initial_state: Dict[str, Any],
+    ) -> None:
+        """Reject unfilled template holes in the raw document, before realizing.
+
+        The post-realize :meth:`_require_ground_document` check sees only the
+        sites realization *kept*, which is too late for two cases:
+
+        - **A — an open site silently swallowed.** When ``schema`` declares a
+          store's type, ``realize`` takes the type from ``schema`` and drops
+          the ``site`` in ``state``; the realized schema no longer contains a
+          hole, so the post-check passes and the composite runs on the type's
+          default value with no error — a template that was never filled runs
+          as if it had been.
+        - **B — an open ``address`` site.** A process/step node whose
+          ``address`` is still a site cannot be realized at all: ``realize``
+          fails inside ``realize_link`` with an opaque ``KeyError: 'data'``
+          before the groundness check can report the real problem.
+
+        Checking the document *as given* — the ``state`` as the caller wrote
+        it, where sites still live — catches both and names the offending
+        site, exactly as the baseline (state-only) case already does. The
+        post-realize check stays as a backstop.
+
+        Checked over **sites** (a ``_default``-carrying site is optional and
+        does not block), consistent with :meth:`_require_ground_document`; see
+        :func:`process_bigraph.templates.required_open_sites`.
+        """
+        try:
+            from bigraph_schema.assembly import interfaces
+            # 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})
+        except Exception:
+            # If the raw document cannot be inspected for any reason, do not
+            # mask that behind this check — fall through to realization and
+            # the post-realize backstop, preserving prior behaviour.
+            return
+
+        if unfilled:
+            self._raise_not_ground(unfilled)
+
     def _require_ground_document(self) -> None:
         """Reject a document that still has unfilled template holes.
 
@@ -2792,6 +2966,10 @@ class Composite(Process):
         Checking here turns what would be a confusing failure deep in the run
         into a clear one at construction.
 
+        This runs *after* realization as a backstop; the primary check is
+        :meth:`_require_ground_input`, which inspects the raw document before
+        realization can swallow or crash on an open site.
+
         Deliberately checked over **sites**, not ``is_ground``: any composite
         containing a process has unwired ports by construction, so
         ``is_ground`` is never true for a real composite and would reject
@@ -2808,12 +2986,7 @@ class Composite(Process):
             if getattr(site, '_default', None) is None})
 
         if unfilled:
-            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`).')
+            self._raise_not_ground(unfilled)
 
     def _require_advancing_interval(
             self,
@@ -2870,6 +3043,23 @@ class Composite(Process):
         This updates the `self.front` to store when the process is due next,
         and captures its update as a deferred computation.
 
+        Read-at-start contract: when the process is due
+        (``process_time <= global_time``), its input state is sliced **now**
+        via ``_cached_view(path)`` and ``process_update`` is called immediately,
+        but the resulting ``Defer`` is stashed in ``self.front[path]['update']``
+        and only applied once ``global_time`` reaches ``future`` (= due time +
+        interval). So inputs are read at the **start** of the interval and the
+        delta lands at the **end**. With unequal intervals this differs from the
+        read-at-event-time ``t*`` rule of Supplement 1 §3.8.2; it is the §3.8.6
+        stash model. See :meth:`run` and the concepts doc for the full contract.
+
+        Note: the ``'future'`` branch below pops a per-process state stash that
+        §3.8.6 uses to keep a long interval chunking-invariant across successive
+        ``run`` calls. Nothing currently writes that key, so a process whose next
+        interval overruns the current ``run`` window is simply deferred and
+        re-reads its inputs on the next ``run`` call (see the chunking caveat on
+        :meth:`run`).
+
         Args:
             path: The path to the process in the state/schema tree.
             process: The dictionary representing the process (must contain 'interval').
@@ -3077,6 +3267,14 @@ class Composite(Process):
         # summary of the state it was handed (process_bigraph.events), then
         # re-raise the ORIGINAL exception unchanged -- callers may classify
         # control-flow exceptions by type, so the type must propagate as is.
+        if self._contract_strict != 'off':
+            compiled = self._compiled_contracts.get(path)
+            if compiled is not None:
+                from process_bigraph.contract_strict import check_pre, handle_violations
+                fails = check_pre(compiled, clean_state)
+                handle_violations(fails, mode=self._contract_strict, phase='pre', path=path,
+                                  cls=type(process['instance']).__name__, emitter=self._em,
+                                  global_time=self.state.get('global_time', 0.0) if isinstance(self.state, dict) else 0.0)
         t0 = _time.monotonic()
         try:
             update = process['instance'].invoke(clean_state, interval)