viva-munk 0.0.2__tar.gz

viva_munk-0.0.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Eran Agmon, Ryan Spangler
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

viva_munk-0.0.2/PKG-INFO

@@ -0,0 +1,153 @@
+Metadata-Version: 2.4
+Name: viva-munk
+Version: 0.0.2
+Summary: multi-cell simulations with pymunk 2d physics
+Author: Ryan Spangler
+Author-email: Eran Agmon <agmon.eran@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/vivarium-collective/Viva-munk
+Project-URL: Repository, https://github.com/vivarium-collective/Viva-munk
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: process-bigraph
+Requires-Dist: bigraph-schema>=0.0.60
+Requires-Dist: bigraph-viz
+Requires-Dist: pymunk
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Requires-Dist: Pillow
+Requires-Dist: plum-dispatch
+Requires-Dist: pbg-superpowers
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: ipdb; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine>=4.0.2; extra == "dev"
+Dynamic: license-file
+
+# viva-munk
+
+[![PyPI version](https://img.shields.io/pypi/v/viva-munk.svg)](https://pypi.org/project/viva-munk/)
+[![Python versions](https://img.shields.io/pypi/pyversions/viva-munk.svg)](https://pypi.org/project/viva-munk/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+Multi-cell simulations with 2D physics, built on [process-bigraph](https://github.com/vivarium-collective/process-bigraph) and [pymunk](https://www.pymunk.org/).
+
+### **[Demos](https://vivarium-collective.github.io/Viva-munk/)**
+
+## Goal
+
+Provide a composable framework for simulating populations of growing, dividing cells with realistic 2D physics and shared chemical environments. Cells are modeled as capsule-shaped rigid bodies (pymunk segments) — or as multi-segment compound bodies that can flex and bend — that grow, divide, secrete particles, attach to surfaces, and interact physically through collisions and confinement. Concentration fields are modeled with a finite-difference diffusion process and coupled to cells through a per-tick exchange step. The framework uses the bigraph process architecture, making it easy to compose new cell behaviors, environmental structures, and analysis pipelines.
+
+Default parameters are calibrated to *E. coli* proportions (~1 μm wide, ~2 μm at birth, ~4 μm at division, ~30–40 min doubling time).
+
+## Installation
+
+Requires Python 3.11+.
+
+```bash
+pip install viva-munk
+```
+
+To use as a library:
+
+```python
+from viva_munk import core_import
+from process_bigraph import Composite
+
+core = core_import()  # registers viva_munk types and processes
+# ... build a spec dict and run: Composite(spec, core=core)
+```
+
+## Quick Start
+
+Run the full experiment suite and generate the HTML report:
+
+```bash
+git clone https://github.com/vivarium-collective/Viva-munk.git
+cd Viva-munk
+pip install -e .[dev]
+
+# Run all experiments and open the HTML report
+python -m viva_munk.experiments.test_suite
+
+# Run without auto-opening the browser
+python -m viva_munk.experiments.test_suite --no-open
+```
+
+## Architecture
+
+```
+viva_munk/
+  pymunk_agent_type.py       # Custom PymunkAgent type with optimized dispatch
+  types/
+    positive.py              # PositiveFloat / PositiveArray / Concentration / SetFloat
+  processes/
+    multibody.py             # PymunkProcess — 2D physics (rigid + bending cells)
+    grow_divide.py           # GrowDivide — exponential growth, division, mutation
+    pressure.py              # Pressure — vectorized per-cell mechanical pressure
+    diffusion_advection.py   # DiffusionAdvection — 2D field diffusion + advection
+    cell_field_exchange.py   # CellFieldExchange — cell ↔ field uptake/secretion
+    secrete_eps.py           # SecreteEPS — EPS particle secretion
+    remove_crossing.py       # RemoveCrossing — remove cells past a boundary
+  plots/
+    multibody_plots.py       # GIF rendering with phylogeny / pressure coloring
+                             # and concentration-field heatmap overlays
+  experiments/
+    test_suite.py            # Experiment registry, runner, HTML report generator
+```
+
+### Processes
+
+- **PymunkProcess** (Process): Manages the pymunk 2D physics space. Handles three kinds of agents — rigid segment cells, multi-segment bending cells (compound bodies linked by pivot joints + damped rotary springs), and circular particles. Syncs state to bodies, steps the physics with sub-stepping, applies damping/jitter, optionally enforces adhesion to a wall, and emits position/velocity/polyline deltas.
+- **GrowDivide** (Process): Per-cell exponential mass growth. Optionally gated by a Monod factor on a local nutrient (`local[nutrient_key]`) and inhibited by mechanical pressure (`exp(-pressure / pressure_k)`). When mass exceeds a threshold, the cell divides into two daughters along its axis; daughters can inherit mutated parameters and (for bending cells) a fresh straight polyline so they don't inherit the mother's pose.
+- **Pressure** (Step): Computes a per-cell mechanical pressure proxy from cell-cell and cell-wall overlap depths (vectorized via numpy). Written back to each cell's `pressure` field for downstream consumers.
+- **DiffusionAdvection** (Process): Explicit FTCS diffusion + upwind advection on a 2D `map[mol_id → array]` field, with ghost-layer boundary conditions (periodic / neumann / dirichlet / dirichlet_ghost).
+- **CellFieldExchange** (Process): Couples `pymunk_agent` cells to a 2D field map. Each tick it samples each cell's local field concentration into `cell.local`, and applies each cell's `cell.exchange` amounts back into the corresponding field bin (Δconcentration = Δamount / bin_volume).
+- **SecreteEPS** (Process): Per-cell EPS particle secretion at a rate proportional to cell mass. Particles are placed on the cell surface and added to the environment. Optionally gated to attached cells only.
+- **RemoveCrossing** (Step): Removes any cell whose position exceeds a configurable x/y boundary. Used to model the flow channel in mother-machine experiments.
+
+### Custom types
+
+`pymunk_agent` is a `Node`-subclass type with hand-optimized `apply`/`reconcile`/`realize`/`check` dispatch (no per-field plum dispatch on the hot path). It carries the geometric and physical state of one cell (mass, radius, length, location, velocity, …) plus optional fields used by downstream processes (`polyline`, `attached`, `pressure`, `local`, `exchange`).
+
+The `viva_munk.types.positive` module provides minimal `PositiveFloat`, `PositiveArray`, `Concentration`, and `SetFloat` types for the field state, accumulator-with-clamp semantics adapted from [spatio-flux](https://github.com/vivarium-collective/spatio-flux).
+
+## Experiments
+
+The current registry (`viva_munk/experiments/test_suite.py`):
+
+- **daughter_machine** — single cell grows in an open chamber with an absorbing right wall.
+- **mother_machine** — narrow dead-end channels (~1.5 μm wide); cells grow vertically and are removed when they reach the flow channel.
+- **with_particles** — cells grow in a chamber seeded with passive particles; cells push and rearrange them.
+- **attachment** — adhesin-bearing cells attach to the bottom surface via PivotJoints; adhesins split between daughters at division.
+- **glucose_growth** — cells on a 2D glucose field. `DiffusionAdvection` spreads glucose, `CellFieldExchange` applies cell consumption every tick, and `GrowDivide` gates rate by Monod kinetics. Cells stop dividing once their local patch is depleted.
+- **bending_pressure** — multi-segment bending capsules grow into a colony. `Pressure` computes mechanical pressure from neighbor / wall contacts and `GrowDivide` applies `exp(-pressure / pressure_k)` inhibition. Cells visibly bend AND slow.
+- **chemotaxis** — twelve non-growing cells run/tumble up a static exponential ligand gradient in a long chamber. Each cell maintains a memory of its local concentration and modulates tumble rate as `λ = λ₀ · exp(-k · dc/dt)`.
+- **inclusion_bodies** — a colony grows while each cell accumulates an inclusion-body aggregate (size in nm, logistic growth toward an 800 nm plateau). Aggregation inhibits growth; at division the IB is transferred entirely to one daughter so the IB-free sibling out-grows the laden one. Cells are soft bending capsules and a `Pressure` step adds a second slowdown as the colony packs. Colored by IB size.
+
+`test_suite.py` runs each one, captures a GIF, a bigraph composition viz, and a serialized state JSON, and generates an HTML report (`out/report.html`) with timing, cell counts, descriptions, and embedded media.
+
+## Dependencies
+
+- [process-bigraph](https://github.com/vivarium-collective/process-bigraph) — bigraph process framework
+- [bigraph-schema](https://github.com/vivarium-collective/bigraph-schema) — typed schemas (via process-bigraph)
+- [bigraph-viz](https://github.com/vivarium-collective/bigraph-viz) — bigraph visualization
+- [pymunk](https://www.pymunk.org/) — 2D physics engine
+- numpy, matplotlib, Pillow, plum-dispatch
+
+## Releasing
+
+Releases are cut from `main` via `./release.sh`, which bumps the patch
+version in `pyproject.toml`, commits + tags `vX.Y.Z`, pushes the tag, builds
+sdist + wheel, and publishes to PyPI (token at `~/.pypi-token`).
+
+## License
+
+MIT — see [LICENSE](LICENSE).

viva_munk-0.0.2/README.md

@@ -0,0 +1,120 @@
+# viva-munk
+
+[![PyPI version](https://img.shields.io/pypi/v/viva-munk.svg)](https://pypi.org/project/viva-munk/)
+[![Python versions](https://img.shields.io/pypi/pyversions/viva-munk.svg)](https://pypi.org/project/viva-munk/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+Multi-cell simulations with 2D physics, built on [process-bigraph](https://github.com/vivarium-collective/process-bigraph) and [pymunk](https://www.pymunk.org/).
+
+### **[Demos](https://vivarium-collective.github.io/Viva-munk/)**
+
+## Goal
+
+Provide a composable framework for simulating populations of growing, dividing cells with realistic 2D physics and shared chemical environments. Cells are modeled as capsule-shaped rigid bodies (pymunk segments) — or as multi-segment compound bodies that can flex and bend — that grow, divide, secrete particles, attach to surfaces, and interact physically through collisions and confinement. Concentration fields are modeled with a finite-difference diffusion process and coupled to cells through a per-tick exchange step. The framework uses the bigraph process architecture, making it easy to compose new cell behaviors, environmental structures, and analysis pipelines.
+
+Default parameters are calibrated to *E. coli* proportions (~1 μm wide, ~2 μm at birth, ~4 μm at division, ~30–40 min doubling time).
+
+## Installation
+
+Requires Python 3.11+.
+
+```bash
+pip install viva-munk
+```
+
+To use as a library:
+
+```python
+from viva_munk import core_import
+from process_bigraph import Composite
+
+core = core_import()  # registers viva_munk types and processes
+# ... build a spec dict and run: Composite(spec, core=core)
+```
+
+## Quick Start
+
+Run the full experiment suite and generate the HTML report:
+
+```bash
+git clone https://github.com/vivarium-collective/Viva-munk.git
+cd Viva-munk
+pip install -e .[dev]
+
+# Run all experiments and open the HTML report
+python -m viva_munk.experiments.test_suite
+
+# Run without auto-opening the browser
+python -m viva_munk.experiments.test_suite --no-open
+```
+
+## Architecture
+
+```
+viva_munk/
+  pymunk_agent_type.py       # Custom PymunkAgent type with optimized dispatch
+  types/
+    positive.py              # PositiveFloat / PositiveArray / Concentration / SetFloat
+  processes/
+    multibody.py             # PymunkProcess — 2D physics (rigid + bending cells)
+    grow_divide.py           # GrowDivide — exponential growth, division, mutation
+    pressure.py              # Pressure — vectorized per-cell mechanical pressure
+    diffusion_advection.py   # DiffusionAdvection — 2D field diffusion + advection
+    cell_field_exchange.py   # CellFieldExchange — cell ↔ field uptake/secretion
+    secrete_eps.py           # SecreteEPS — EPS particle secretion
+    remove_crossing.py       # RemoveCrossing — remove cells past a boundary
+  plots/
+    multibody_plots.py       # GIF rendering with phylogeny / pressure coloring
+                             # and concentration-field heatmap overlays
+  experiments/
+    test_suite.py            # Experiment registry, runner, HTML report generator
+```
+
+### Processes
+
+- **PymunkProcess** (Process): Manages the pymunk 2D physics space. Handles three kinds of agents — rigid segment cells, multi-segment bending cells (compound bodies linked by pivot joints + damped rotary springs), and circular particles. Syncs state to bodies, steps the physics with sub-stepping, applies damping/jitter, optionally enforces adhesion to a wall, and emits position/velocity/polyline deltas.
+- **GrowDivide** (Process): Per-cell exponential mass growth. Optionally gated by a Monod factor on a local nutrient (`local[nutrient_key]`) and inhibited by mechanical pressure (`exp(-pressure / pressure_k)`). When mass exceeds a threshold, the cell divides into two daughters along its axis; daughters can inherit mutated parameters and (for bending cells) a fresh straight polyline so they don't inherit the mother's pose.
+- **Pressure** (Step): Computes a per-cell mechanical pressure proxy from cell-cell and cell-wall overlap depths (vectorized via numpy). Written back to each cell's `pressure` field for downstream consumers.
+- **DiffusionAdvection** (Process): Explicit FTCS diffusion + upwind advection on a 2D `map[mol_id → array]` field, with ghost-layer boundary conditions (periodic / neumann / dirichlet / dirichlet_ghost).
+- **CellFieldExchange** (Process): Couples `pymunk_agent` cells to a 2D field map. Each tick it samples each cell's local field concentration into `cell.local`, and applies each cell's `cell.exchange` amounts back into the corresponding field bin (Δconcentration = Δamount / bin_volume).
+- **SecreteEPS** (Process): Per-cell EPS particle secretion at a rate proportional to cell mass. Particles are placed on the cell surface and added to the environment. Optionally gated to attached cells only.
+- **RemoveCrossing** (Step): Removes any cell whose position exceeds a configurable x/y boundary. Used to model the flow channel in mother-machine experiments.
+
+### Custom types
+
+`pymunk_agent` is a `Node`-subclass type with hand-optimized `apply`/`reconcile`/`realize`/`check` dispatch (no per-field plum dispatch on the hot path). It carries the geometric and physical state of one cell (mass, radius, length, location, velocity, …) plus optional fields used by downstream processes (`polyline`, `attached`, `pressure`, `local`, `exchange`).
+
+The `viva_munk.types.positive` module provides minimal `PositiveFloat`, `PositiveArray`, `Concentration`, and `SetFloat` types for the field state, accumulator-with-clamp semantics adapted from [spatio-flux](https://github.com/vivarium-collective/spatio-flux).
+
+## Experiments
+
+The current registry (`viva_munk/experiments/test_suite.py`):
+
+- **daughter_machine** — single cell grows in an open chamber with an absorbing right wall.
+- **mother_machine** — narrow dead-end channels (~1.5 μm wide); cells grow vertically and are removed when they reach the flow channel.
+- **with_particles** — cells grow in a chamber seeded with passive particles; cells push and rearrange them.
+- **attachment** — adhesin-bearing cells attach to the bottom surface via PivotJoints; adhesins split between daughters at division.
+- **glucose_growth** — cells on a 2D glucose field. `DiffusionAdvection` spreads glucose, `CellFieldExchange` applies cell consumption every tick, and `GrowDivide` gates rate by Monod kinetics. Cells stop dividing once their local patch is depleted.
+- **bending_pressure** — multi-segment bending capsules grow into a colony. `Pressure` computes mechanical pressure from neighbor / wall contacts and `GrowDivide` applies `exp(-pressure / pressure_k)` inhibition. Cells visibly bend AND slow.
+- **chemotaxis** — twelve non-growing cells run/tumble up a static exponential ligand gradient in a long chamber. Each cell maintains a memory of its local concentration and modulates tumble rate as `λ = λ₀ · exp(-k · dc/dt)`.
+- **inclusion_bodies** — a colony grows while each cell accumulates an inclusion-body aggregate (size in nm, logistic growth toward an 800 nm plateau). Aggregation inhibits growth; at division the IB is transferred entirely to one daughter so the IB-free sibling out-grows the laden one. Cells are soft bending capsules and a `Pressure` step adds a second slowdown as the colony packs. Colored by IB size.
+
+`test_suite.py` runs each one, captures a GIF, a bigraph composition viz, and a serialized state JSON, and generates an HTML report (`out/report.html`) with timing, cell counts, descriptions, and embedded media.
+
+## Dependencies
+
+- [process-bigraph](https://github.com/vivarium-collective/process-bigraph) — bigraph process framework
+- [bigraph-schema](https://github.com/vivarium-collective/bigraph-schema) — typed schemas (via process-bigraph)
+- [bigraph-viz](https://github.com/vivarium-collective/bigraph-viz) — bigraph visualization
+- [pymunk](https://www.pymunk.org/) — 2D physics engine
+- numpy, matplotlib, Pillow, plum-dispatch
+
+## Releasing
+
+Releases are cut from `main` via `./release.sh`, which bumps the patch
+version in `pyproject.toml`, commits + tags `vX.Y.Z`, pushes the tag, builds
+sdist + wheel, and publishes to PyPI (token at `~/.pypi-token`).
+
+## License
+
+MIT — see [LICENSE](LICENSE).

viva_munk-0.0.2/pyproject.toml

@@ -0,0 +1,81 @@
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "viva-munk"
+version = "0.0.2"
+description = "multi-cell simulations with pymunk 2d physics"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.11"
+authors = [
+  {name = "Eran Agmon", email = "agmon.eran@gmail.com"},
+  {name = "Ryan Spangler"},
+]
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "process-bigraph",
+    "bigraph-schema>=0.0.60",
+    "bigraph-viz",
+    "pymunk",
+    "numpy",
+    "matplotlib",
+    "Pillow",
+    "plum-dispatch",
+    # viva_munk/visualizations/* subclass pbg_superpowers.visualization.Visualization.
+    "pbg-superpowers",
+    # NOTE on spatio-flux: viva_munk/__init__.py imports
+    # `from spatio_flux.visualizations import (...)` at module-import
+    # time, but no PyPI-published spatio-flux release ships a
+    # `visualizations/` submodule (it was dropped in 1.4 in favour of
+    # `plots/`; the dev 1.0.0 still has it but is not on PyPI). Listing
+    # `spatio-flux` here would let pip install succeed but the import
+    # would still fail. Tracked separately: either refactor viva_munk's
+    # __init__ to use spatio_flux.plots, vendor what we need, or
+    # publish a 1.0.x patch with the legacy visualizations layout.
+    # Until then, viva-munk is installable only against a local
+    # editable spatio-flux checkout that has visualizations/.
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest",
+    "ipdb",
+    "build",
+    "twine>=4.0.2",
+]
+
+[project.urls]
+Homepage = "https://github.com/vivarium-collective/Viva-munk"
+Repository = "https://github.com/vivarium-collective/Viva-munk"
+
+# Auto-discover every viva_munk subpackage at build time. The hand-
+# maintained list previously skipped `viva_munk.composites` AND
+# `viva_munk.visualizations`, so the published wheel didn't include
+# those directories at all and `import viva_munk` broke on any clean
+# install (the package's own __init__.py imports them). The
+# auto-discovery pattern matches what spatio-flux does.
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["viva_munk*"]
+exclude = ["tests*", "docs*", "studies*"]
+
+# NOTE: this package previously declared a [tool.uv.sources] override
+# pointing process-bigraph at `../process-bigraph` (editable). That
+# section is dev-only convenience for working in a sibling checkout
+# layout — but it leaks into downstream consumers when viva-munk is
+# pulled as a git dependency, because uv resolves the transitive
+# source path as `subdirectory=../process-bigraph` of the git URL,
+# which doesn't exist. Removed for now; if you need the local
+# editable checkout, install it explicitly:
+#
+#   pip install -e ../process-bigraph
+#
+# or add the override in YOUR project's pyproject.toml (not here).

viva_munk-0.0.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

viva_munk-0.0.2/viva_munk/__init__.py

@@ -0,0 +1,174 @@
+"""
+Registration-related functions
+"""
+
+__version__ = "0.0.1"
+
+from process_bigraph import register_types as pb_register_types
+from process_bigraph.types.process import register_types as pb_types_register
+from process_bigraph.composite import Composite
+from process_bigraph.emitter import RAMEmitter, SQLiteEmitter
+from bigraph_schema.core import Core, BASE_TYPES
+from bigraph_viz import register_types as viz_register_types
+
+from viva_munk.processes.multibody import PymunkProcess
+from viva_munk.processes.grow_divide import GrowDivide, AdderGrowDivide
+from viva_munk.processes.remove_crossing import RemoveCrossing
+from viva_munk.processes.secrete_eps import SecreteEPS
+from viva_munk.processes.pressure import Pressure
+from viva_munk.processes.diffusion_advection import DiffusionAdvection
+from viva_munk.processes.cell_field_exchange import CellFieldExchange
+from viva_munk.processes.chemotaxis import Chemotaxis
+from viva_munk.processes.inclusion_body import InclusionBody, IBColony
+from viva_munk.processes.quorum_sensing import QuorumSensing
+from viva_munk.processes.field_decay import FieldDecay
+# Spatio-flux processes referenced by spatio_flux.composites.particles.* —
+# brownian_particles needs both BrownianMovement and ManageBoundaries to
+# resolve their `local:` addresses at run time.
+from spatio_flux.processes.particles import BrownianMovement, ManageBoundaries
+# Spatio-flux Visualization Steps — heatmaps, GIFs, snapshot grids, and
+# emitter-driven timeseries. Registered so dashboard users can attach them
+# to any composite via the Visualizations tab.
+from spatio_flux.visualizations import (
+    FieldHeatmap,
+    FieldAnimationGif,
+    FieldSnapshotsGrid,
+    ParticleTraces,
+    TestSuiteTimeSeries,
+)
+from viva_munk.pymunk_agent_type import PymunkAgent, register_pymunk_agent_dispatches
+from viva_munk.types import positive_types
+from viva_munk.visualizations import MultibodyVizStep, CellMassTraces
+
+# Register custom dispatches once at module import
+register_pymunk_agent_dispatches()
+
+
+def _patch_composite_realize_on_sentinels():
+    """Ensure Composite re-realizes newly-added subtrees on `_add`/`_remove`.
+
+    `Map.apply` drops `_add` entries straight into state without calling
+    the value type's realize path, and `Composite.apply_updates` only
+    triggers `core.realize` on schema-level merges — not on structural
+    sentinels. So embedded process specs (e.g. `grow_divide` on a freshly
+    divided daughter) are never instantiated: the spec is visible in
+    state but its `'instance'` slot stays unset and the Process class
+    never runs on that cell. Result: lineages freeze after the first
+    division in every experiment that uses per-cell embedded processes.
+
+    The fix is a one-line amend: when structural sentinels are detected,
+    run `core.realize` (which follows `Link`/process specs and creates
+    instances via `realize_link`) before `find_instance_paths` scans
+    state for them.
+    """
+    _original_apply_updates = Composite.apply_updates
+
+    def apply_updates_with_realize(self, updates):
+        update_paths = _original_apply_updates(self, updates)
+        if getattr(self, '_last_apply_structural', False):
+            # bigraph_schema.core.realize now returns a 3-tuple
+            # (schema, state, escape_merges). At top-level realize there
+            # is nothing above us for merges to escape to, so discard.
+            self.schema, self.state, _escape_merges = self.core.realize(
+                self.schema, self.state)
+            self.find_instance_paths(self.state)
+            self._build_view_project_cache()
+        return update_paths
+
+    Composite.apply_updates = apply_updates_with_realize
+
+
+_patch_composite_realize_on_sentinels()
+
+
+def _patch_list_apply_tuple_update():
+    """Make ``apply(schema: List, state: list, update: tuple)`` do
+    element-wise add when shape + numeric content match.
+
+    JSON serialization drops the tuple type, so a state that started as a
+    ``(x, y)`` tuple becomes a ``[x, y]`` list and schema inference picks
+    ``List(_element=Float)`` instead of ``Tuple(_values=[Float, Float])``.
+    The default ``apply(List)`` then does ``state + update`` — concat, not
+    element-wise — and crashes on the ``list + tuple`` type mismatch the
+    moment a process emits a tuple delta (``PymunkProcess`` does this for
+    ``location``/``velocity`` every tick). Pin element-wise behavior for
+    the JSON-roundtripped case so the dashboard's subprocess flow works.
+    """
+    from plum import dispatch
+    from bigraph_schema.schema import List
+    from bigraph_schema.methods.apply import apply as _apply
+
+    @_apply.dispatch
+    def apply_list_with_tuple_update(schema: List, state: list, update: tuple, path):
+        if len(state) == len(update) and all(
+            isinstance(s, (int, float)) for s in state
+        ):
+            return [s + u for s, u in zip(state, update)], []
+        # Length mismatch or non-numeric: fall back to concat (matches
+        # the default ``state + list(update)`` semantics).
+        return list(state) + list(update), []
+
+
+_patch_list_apply_tuple_update()
+
+
+from viva_munk import composites as _composites  # noqa: E402,F401 — fires @composite_generator side-effects
+
+
+def register_pymunk_types(core):
+    # Use the optimized PymunkAgent Node subclass instead of a dict schema.
+    # This eliminates per-field dispatch overhead in apply/reconcile/realize.
+    core.register_type('pymunk_agent', PymunkAgent())
+    # NOTE: viva_munk.types.positive_types overlaps with spatio_flux's on
+    # ('positive_float', 'positive_array', 'concentration', 'set_float') —
+    # viva_munk uses instances (PositiveFloat()), spatio_flux uses classes
+    # (PositiveFloat). Registering both forms triggers a resolve conflict in
+    # bigraph_schema. spatio_flux's set is a strict superset (adds count,
+    # mass, delta_conc), so we let spatio_flux_register_types own these
+    # types in core_import() and skip the duplicate loop here.
+
+
+def register_processes(core):
+    core.register_link('PymunkProcess', PymunkProcess)
+    core.register_link('GrowDivide', GrowDivide)
+    core.register_link('AdderGrowDivide', AdderGrowDivide)
+    core.register_link('RemoveCrossing', RemoveCrossing)
+    core.register_link('SecreteEPS', SecreteEPS)
+    core.register_link('Pressure', Pressure)
+    core.register_link('DiffusionAdvection', DiffusionAdvection)
+    core.register_link('CellFieldExchange', CellFieldExchange)
+    core.register_link('Chemotaxis', Chemotaxis)
+    core.register_link('InclusionBody', InclusionBody)
+    core.register_link('IBColony', IBColony)
+    core.register_link('QuorumSensing', QuorumSensing)
+    core.register_link('FieldDecay', FieldDecay)
+    core.register_link('BrownianMovement', BrownianMovement)
+    core.register_link('ManageBoundaries', ManageBoundaries)
+    core.register_link('MultibodyVizStep', MultibodyVizStep)
+    core.register_link('CellMassTraces', CellMassTraces)
+    # Spatio-flux Visualization Steps
+    core.register_link('FieldHeatmap', FieldHeatmap)
+    core.register_link('FieldAnimationGif', FieldAnimationGif)
+    core.register_link('FieldSnapshotsGrid', FieldSnapshotsGrid)
+    core.register_link('ParticleTraces', ParticleTraces)
+    core.register_link('TestSuiteTimeSeries', TestSuiteTimeSeries)
+    core.register_link('Composite', Composite)
+    core.register_link('RAMEmitter', RAMEmitter)
+    core.register_link('SQLiteEmitter', SQLiteEmitter)
+
+
+def core_import(core=None, config=None):
+    if not core:
+        core = Core(BASE_TYPES)
+    pb_types_register(core)
+    pb_register_types(core)
+    viz_register_types(core)
+    # Spatio-flux types (particle, position, bounds, fields, ...) are
+    # referenced by spatio_flux.composites.particles.* and other composites
+    # used in this workspace. Their Process classes (registered below) declare
+    # ports like 'map[particle]' that won't resolve without these types.
+    from spatio_flux import register_types as spatio_flux_register_types
+    spatio_flux_register_types(core)
+    register_pymunk_types(core)
+    register_processes(core)
+    return core

viva_munk-0.0.2/viva_munk/composites/__init__.py

@@ -0,0 +1,104 @@
+"""Composite-generator registrations for viva-munk's experiment documents.
+
+Each function here is a thin `@composite_generator`-decorated wrapper around
+the corresponding `*_document(config=None)` builder in
+`viva_munk.experiments.documents`. The decorator side-effect (registering
+into pbg-superpowers' `_REGISTRY`) is what makes these visible to the
+vivarium-dashboard's composite browser.
+
+Parameters intentionally left unexposed for now — call sites get the
+builder's default config. Per-composite kwargs can be surfaced later by
+filling in `parameters=` on the decorator.
+"""
+from pbg_superpowers.composite_generator import composite_generator
+
+from viva_munk.experiments.documents.attachment import attachment_document
+from viva_munk.experiments.documents.bending_pressure import bending_pressure_document
+from viva_munk.experiments.documents.biofilm import biofilm_document
+from viva_munk.experiments.documents.chemotaxis import chemotaxis_document
+from viva_munk.experiments.documents.daughter_machine import daughter_machine_document
+from viva_munk.experiments.documents.glucose_growth import glucose_growth_document
+from viva_munk.experiments.documents.inclusion_bodies import inclusion_bodies_document
+from viva_munk.experiments.documents.mother_machine import mother_machine_document
+from viva_munk.experiments.documents.quorum_sensing import quorum_sensing_document
+
+
+@composite_generator(
+    name="attachment",
+    description="Cells settling/attaching on a surface.",
+    default_n_steps=200,
+)
+def attachment(core=None) -> dict:
+    return attachment_document()
+
+
+@composite_generator(
+    name="bending_pressure",
+    description="Bending-pressure rod-like cells.",
+    default_n_steps=200,
+)
+def bending_pressure(core=None) -> dict:
+    return bending_pressure_document()
+
+
+@composite_generator(
+    name="biofilm",
+    description="Growing biofilm with EPS secretion + pressure dynamics.",
+    default_n_steps=500,
+)
+def biofilm(core=None) -> dict:
+    return biofilm_document()
+
+
+@composite_generator(
+    name="chemotaxis",
+    description="Run/tumble chemotaxis up a static 2D ligand gradient.",
+    default_n_steps=200,
+)
+def chemotaxis(core=None) -> dict:
+    return chemotaxis_document()
+
+
+@composite_generator(
+    name="daughter_machine",
+    description="Daughter-machine geometry: tracking daughter cells.",
+    default_n_steps=300,
+)
+def daughter_machine(core=None) -> dict:
+    return daughter_machine_document()
+
+
+@composite_generator(
+    name="glucose_growth",
+    description="Glucose-driven growth and division.",
+    default_n_steps=300,
+)
+def glucose_growth(core=None) -> dict:
+    return glucose_growth_document()
+
+
+@composite_generator(
+    name="inclusion_bodies",
+    description="Inclusion-body accumulation across a growing colony.",
+    default_n_steps=500,
+)
+def inclusion_bodies(core=None) -> dict:
+    return inclusion_bodies_document()
+
+
+@composite_generator(
+    name="mother_machine",
+    description="Mother-machine geometry: single-channel cell trapping.",
+    default_n_steps=300,
+)
+def mother_machine(core=None) -> dict:
+    return mother_machine_document()
+
+
+@composite_generator(
+    name="quorum_sensing",
+    description="Quorum-sensing autoinducer feedback in a growing colony.",
+    default_n_steps=300,
+)
+def quorum_sensing(core=None) -> dict:
+    return quorum_sensing_document()

viva_munk-0.0.2/viva_munk/core.py

@@ -0,0 +1,5 @@
+from viva_munk import core_import
+
+
+def build_core():
+    return core_import()