Multi-plants

.gitattributes

@@ -0,0 +1,2 @@
+# Generated bundles may preserve whitespace inside dependency template literals.
+frontend/dist/assets/*.js -whitespace

.github/scripts/configure_local_sources.jl

@@ -0,0 +1,100 @@
+module IntegrationSourceConfig
+
+using TOML
+
+export configure_local_sources!
+
+const DIRECT_DEPENDENCY_SECTIONS = ("deps", "extras")
+
+function _source_identity(source_root::AbstractString)
+    source_path = realpath(source_root)
+    project_file = joinpath(source_path, "Project.toml")
+    isfile(project_file) || error("Missing source project: $(project_file)")
+
+    project = TOML.parsefile(project_file)
+    name = get(project, "name", nothing)
+    uuid = get(project, "uuid", nothing)
+    name isa AbstractString || error("Missing package name in $(project_file)")
+    uuid isa AbstractString || error("Missing package UUID in $(project_file)")
+
+    return (; name=String(name), uuid=String(uuid), path=source_path)
+end
+
+function _declared_uuid(project, package_name::AbstractString)
+    declared_uuid = nothing
+    for section_name in DIRECT_DEPENDENCY_SECTIONS
+        section = get(project, section_name, nothing)
+        section isa AbstractDict || continue
+        haskey(section, package_name) || continue
+
+        uuid = String(section[package_name])
+        if declared_uuid !== nothing && declared_uuid != uuid
+            error("Conflicting UUIDs for $(package_name) in [deps] and [extras]")
+        end
+        declared_uuid = uuid
+    end
+    return declared_uuid
+end
+
+function _configured_project(project_file::AbstractString, source_identities)
+    project_path = realpath(project_file)
+    project = TOML.parsefile(project_path)
+    sources = get!(project, "sources", Dict{String,Any}())
+    matched = String[]
+    changed = String[]
+
+    for source in source_identities
+        declared_uuid = _declared_uuid(project, source.name)
+        declared_uuid === nothing && continue
+        declared_uuid == source.uuid || error(
+            "UUID mismatch for $(source.name) in $(project_path): " *
+            "expected $(source.uuid), found $(declared_uuid)",
+        )
+
+        push!(matched, source.name)
+        local_source = Dict{String,Any}("path" => source.path)
+        get(sources, source.name, nothing) == local_source && continue
+        sources[source.name] = local_source
+        push!(changed, source.name)
+    end
+
+    return (; path=project_path, contents=project, matched, changed)
+end
+
+"""
+    configure_local_sources!(project_files, source_roots)
+
+Replace URL/revision source entries with absolute paths to exact local package
+checkouts. A source is changed only when the target project declares the same
+package UUID in `[deps]` or `[extras]`; weak dependencies are intentionally not
+modified. Every requested source must match at least one target project.
+"""
+function configure_local_sources!(project_files, source_roots)
+    source_identities = map(_source_identity, source_roots)
+    source_names = getproperty.(source_identities, :name)
+    allunique(source_names) || error("Each local source package must be unique")
+
+    configured_projects = map(project_files) do project_file
+        isfile(project_file) || error("Missing target project: $(abspath(project_file))")
+        _configured_project(project_file, source_identities)
+    end
+
+    for source_name in source_names
+        any(source_name in project.matched for project in configured_projects) || error(
+            "Local source $(source_name) is not a direct dependency of any target project",
+        )
+    end
+
+    for project in configured_projects
+        isempty(project.changed) && continue
+        open(project.path, "w") do io
+            TOML.print(io, project.contents; sorted=true)
+        end
+    end
+
+    return map(configured_projects) do project
+        (; project=project.path, matched=project.matched, changed=project.changed)
+    end
+end
+
+end

.github/scripts/test_configure_local_sources.jl

@@ -0,0 +1,155 @@
+using Test
+using TOML
+
+include(joinpath(@__DIR__, "configure_local_sources.jl"))
+
+function write_project(path, project)
+    mkpath(dirname(path))
+    open(path, "w") do io
+        TOML.print(io, project; sorted=true)
+    end
+end
+
+function source_project(root, name, uuid)
+    write_project(
+        joinpath(root, "Project.toml"),
+        Dict{String,Any}("name" => name, "uuid" => uuid, "version" => "1.0.0"),
+    )
+end
+
+@testset "Configure local integration sources" begin
+    mktempdir() do tmp
+        pse_uuid = "9a576370-710b-4269-adf9-4f603a9c6423"
+        plantgeom_uuid = "5edaa67e-25db-4eb9-bf81-05d793b2238d"
+        xpalm_uuid = "6b523e1e-d512-416c-8e51-a8fbef0064e7"
+
+        pse_root = joinpath(tmp, "PlantSimEngine")
+        plantgeom_root = joinpath(tmp, "PlantGeom")
+        source_project(pse_root, "PlantSimEngine", pse_uuid)
+        source_project(plantgeom_root, "PlantGeom", plantgeom_uuid)
+
+        xpalm_root = joinpath(tmp, "XPalm")
+        root_project = joinpath(xpalm_root, "Project.toml")
+        test_project = joinpath(xpalm_root, "test", "Project.toml")
+        write_project(
+            root_project,
+            Dict{String,Any}(
+                "name" => "XPalm",
+                "uuid" => xpalm_uuid,
+                "deps" => Dict(
+                    "PlantSimEngine" => pse_uuid,
+                    "PlantGeom" => plantgeom_uuid,
+                ),
+                "sources" => Dict(
+                    "PlantSimEngine" => Dict("url" => "https://example.test/pse", "rev" => "old"),
+                    "PlantGeom" => Dict("url" => "https://example.test/plantgeom", "rev" => "old"),
+                    "Unrelated" => Dict("path" => "../Unrelated"),
+                ),
+            ),
+        )
+        write_project(
+            test_project,
+            Dict{String,Any}(
+                "deps" => Dict(
+                    "XPalm" => xpalm_uuid,
+                    "PlantSimEngine" => pse_uuid,
+                    "PlantGeom" => plantgeom_uuid,
+                ),
+                "sources" => Dict(
+                    "XPalm" => Dict("path" => ".."),
+                    "PlantSimEngine" => Dict("url" => "https://example.test/pse", "rev" => "old"),
+                    "PlantGeom" => Dict("url" => "https://example.test/plantgeom", "rev" => "old"),
+                ),
+            ),
+        )
+
+        summaries = IntegrationSourceConfig.configure_local_sources!(
+            (root_project, test_project),
+            (pse_root, plantgeom_root),
+        )
+        @test all(summary.changed == ["PlantSimEngine", "PlantGeom"] for summary in summaries)
+
+        configured_root = TOML.parsefile(root_project)
+        configured_test = TOML.parsefile(test_project)
+        @test configured_root["sources"]["PlantSimEngine"] == Dict("path" => realpath(pse_root))
+        @test configured_root["sources"]["PlantGeom"] == Dict("path" => realpath(plantgeom_root))
+        @test configured_root["sources"]["Unrelated"] == Dict("path" => "../Unrelated")
+        @test configured_test["sources"]["XPalm"] == Dict("path" => "..")
+
+        repeated = IntegrationSourceConfig.configure_local_sources!(
+            (root_project, test_project),
+            (pse_root, plantgeom_root),
+        )
+        @test all(isempty(summary.changed) for summary in repeated)
+
+        weakdep_root = joinpath(plantgeom_root, "Project.toml")
+        weakdep_test = joinpath(plantgeom_root, "test", "Project.toml")
+        write_project(
+            weakdep_root,
+            Dict{String,Any}(
+                "name" => "PlantGeom",
+                "uuid" => plantgeom_uuid,
+                "weakdeps" => Dict("PlantSimEngine" => pse_uuid),
+            ),
+        )
+        write_project(
+            weakdep_test,
+            Dict{String,Any}(
+                "deps" => Dict(
+                    "PlantGeom" => plantgeom_uuid,
+                    "PlantSimEngine" => pse_uuid,
+                ),
+                "sources" => Dict("PlantGeom" => Dict("path" => "..")),
+            ),
+        )
+
+        weakdep_summaries = IntegrationSourceConfig.configure_local_sources!(
+            (weakdep_root, weakdep_test),
+            (pse_root,),
+        )
+        @test isempty(weakdep_summaries[1].matched)
+        @test weakdep_summaries[2].changed == ["PlantSimEngine"]
+        @test !haskey(TOML.parsefile(weakdep_root), "sources")
+        @test TOML.parsefile(weakdep_test)["sources"]["PlantSimEngine"] ==
+              Dict("path" => realpath(pse_root))
+
+        extras_project = joinpath(tmp, "Extras", "Project.toml")
+        write_project(
+            extras_project,
+            Dict{String,Any}("extras" => Dict("PlantSimEngine" => pse_uuid)),
+        )
+        extras_summary = only(IntegrationSourceConfig.configure_local_sources!(
+            (extras_project,),
+            (pse_root,),
+        ))
+        @test extras_summary.changed == ["PlantSimEngine"]
+        @test TOML.parsefile(extras_project)["sources"]["PlantSimEngine"] ==
+              Dict("path" => realpath(pse_root))
+
+        mismatched_project = joinpath(tmp, "Mismatch", "Project.toml")
+        write_project(
+            mismatched_project,
+            Dict{String,Any}(
+                "deps" => Dict("PlantSimEngine" => "00000000-0000-0000-0000-000000000000"),
+            ),
+        )
+        transaction_project = joinpath(tmp, "Transaction", "Project.toml")
+        write_project(
+            transaction_project,
+            Dict{String,Any}(
+                "deps" => Dict("PlantSimEngine" => pse_uuid),
+                "sources" => Dict(
+                    "PlantSimEngine" => Dict("url" => "https://example.test/pse", "rev" => "old"),
+                ),
+            ),
+        )
+        @test_throws ErrorException IntegrationSourceConfig.configure_local_sources!(
+            (transaction_project, mismatched_project),
+            (pse_root,),
+        )
+        @test haskey(
+            TOML.parsefile(transaction_project)["sources"]["PlantSimEngine"],
+            "url",
+        )
+    end
+end

.github/workflows/Benchmarks.yml

@@ -3,23 +3,109 @@ on:
   pull_request_target:
     branches: [ main ]
   workflow_dispatch:
+    inputs:
+      full_performance:
+        description: Run the complete downstream performance workflow
+        required: false
+        default: false
+        type: boolean
 permissions:
   pull-requests: write
+  contents: read
 jobs:
   bench:
-    name: Julia ${{ matrix.version }} - ${{ matrix.os }} - ${{ github.event_name }}
+    if: ${{ github.event_name != 'workflow_dispatch' || !inputs.full_performance }}
+    name: Julia ${{ matrix.version }} - ${{ matrix.os }} - ${{ matrix.arch }} - ${{
+      github.event_name }}
     runs-on: ${{ matrix.os }}
     timeout-minutes: 60
+    env:
+      PSE_BENCHMARK_INCLUDE_DOWNSTREAM: "false"
     strategy:
       fail-fast: false
       matrix:
         version:
-          - "1"
+          - "1.12.1"
         os:
           - ubuntu-latest
+        arch:
+          - x64
     steps:
       - uses: MilesCranmer/AirspeedVelocity.jl@action-v1
         with:
           julia-version: ${{ matrix.version }}
           bench-on: ${{ github.event.pull_request.head.sha }}
-          extra-pkgs: https://github.com/PalmStudio/XPalm.jl,https://github.com/VEZY/PlantBiophysics.jl
+
+  plantbiophysics:
+    if: ${{ github.event_name != 'workflow_dispatch' || !inputs.full_performance }}
+    name: PlantBiophysics multi-timestep
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    permissions:
+      contents: read
+    env:
+      JULIA_NUM_THREADS: "1"
+      JULIA_PKG_PRECOMPILE_AUTO: "0"
+      PSE_PLANTBIOPHYSICS_BENCHMARK_STEPS: "1000"
+      PSE_PLANTBIOPHYSICS_BENCHMARK_SAMPLES: "5"
+      PSE_PLANTBIOPHYSICS_FANOUT_SCENES: "20"
+    steps:
+      - name: Check out PlantSimEngine
+        uses: actions/checkout@v7
+        with:
+          ref: ${{ github.event.pull_request.head.sha || github.ref }}
+
+      - name: Check out PlantBiophysics
+        uses: actions/checkout@v7
+        with:
+          repository: VEZY/PlantBiophysics.jl
+          ref: multi-plant
+          path: downstream/PlantBiophysics
+
+      - name: Set up Julia
+        uses: julia-actions/setup-julia@v3
+        with:
+          version: "1.12.1"
+
+      - name: Cache Julia packages
+        uses: julia-actions/cache@v3
+
+      - name: Resolve the PlantBiophysics benchmark environment
+        shell: julia --project=benchmark --color=yes {0}
+        run: |
+          using Pkg
+
+          benchmark_project = joinpath(pwd(), "benchmark", "Project.toml")
+          include(joinpath(pwd(), "benchmark", "prepare_full_performance_project.jl"))
+          prepare_plantbiophysics_performance_project!(benchmark_project)
+          Pkg.activate(joinpath(pwd(), "benchmark"))
+          Pkg.develop([
+              PackageSpec(path=pwd()),
+              PackageSpec(path=joinpath(pwd(), "downstream", "PlantBiophysics")),
+          ])
+          Pkg.resolve()
+          Pkg.instantiate()
+          Pkg.precompile()
+
+      - name: Run the warmed multi-timestep benchmark
+        run: >-
+          julia --project=benchmark --color=yes
+          benchmark/test/runtests.jl
+          "PlantBiophysics benchmark (API smoke|performance)"
+
+      - name: Persist measurements
+        if: always()
+        uses: actions/upload-artifact@v7
+        with:
+          name: plantbiophysics-performance-${{ github.run_id }}-${{ github.run_attempt }}
+          path: benchmark/results/plantbiophysics-full-latest.csv
+          if-no-files-found: warn
+          retention-days: 30
+
+  full-performance:
+    if: ${{ github.event_name == 'workflow_dispatch' && inputs.full_performance }}
+    uses: ./.github/workflows/FullPerformance.yml
+    with:
+      xpalm_ref: codex/xpalm-release-regression
+      plantbiophysics_ref: multi-plant
+      plantgeom_ref: plantsimengine-multi-plant