cmake: make CMake-native addon packaging the default (via avnd_addon_finalize)

Every avendish addon already calls avnd_addon_finalize(); in a standalone
(non-score) build it now assembles the per-backend distributable packages
automatically through avnd_addon_package(), so addons ship the full layout
— externals + the generated help/example patches + LICENSE/README — with
no per-addon packaging code and no opt-in.

- avnd_addon_finalize: standalone branch calls avnd_addon_package for all
  backends (empty ones skip themselves). An addon that needs to bundle a
  runtime dependency still calls avnd_addon_package(... SUPPORT ...) itself
  before finalize; a global guard makes the auto-call stand down so we never
  package twice.
- New avnd_create_pd_addon_package (flat externals + <c_name>-help.pd) and
  avnd_create_python_addon_package (py<c_name>.so + a generated __init__.py
  re-export shim + examples/<c_name>_example.py), wired into
  avnd_addon_package's dispatch. max/touchdesigner/godot already had packagers
  that copy their help/example properties; they are now simply auto-invoked.
- avnd_make_pd / avnd_make_python register their externals in the
  AVND_ALL_<BK>_EXTERNALS globals the orchestrator enumerates, like the other
  backends already did.

Verified against score-addon-puara (unmodified): a PD-only build now emits
build/package/score_addon_puara/ with all 26 externals + 26 matching
-help.pd patches; a Python-only build emits the 26 modules + __init__.py
(imports and re-exports all 26) + 26 examples.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: jcelerier

cmake/AvendishAddon.cmake

@@ -133,5 +133,19 @@ macro(avnd_addon_finalize)
       BASE_TARGET ${AA_NAME}
       PLUGIN_UUID ${AA_UUID}
       PLUGIN_VERSION ${AA_VERSION})
+  else()
+    # Standalone: assemble the distributable packages from CMake by default, so
+    # every addon ships the per-backend layout (externals + generated help /
+    # example patches + metadata) with no per-addon packaging code. An addon that
+    # must bundle a runtime dependency calls avnd_addon_package(... SUPPORT ...)
+    # itself before finalize; that sets the guard below so we don't package twice.
+    # Each back-end whose externals weren't built is skipped inside the call.
+    get_property(_avnd_pkg_done GLOBAL PROPERTY AVND_ADDON_PACKAGE_INVOKED)
+    if(NOT _avnd_pkg_done AND COMMAND avnd_addon_package)
+      avnd_addon_package(
+        NAME "${AA_NAME}"
+        SOURCE_PATH "${CMAKE_CURRENT_SOURCE_DIR}"
+        BACKENDS max pd python touchdesigner godot)
+    endif()
   endif()
 endmacro()

cmake/avendish.packaging.cmake

@@ -162,6 +162,141 @@ function(avnd_create_max_addon_package)
   endforeach()
 endfunction()
 
+# --- Pure Data (addon) ------------------------------------------------------
+#
+# avnd_create_pd_addon_package(
+#   NAME <addon-name> SOURCE_PATH <dir> PACKAGE_ROOT <dir>
+#   EXTERNALS <target> ...      # the *_pd external targets
+#   [SUPPORT <file> ...])
+#
+# Pd resolves an external and its <name>-help.pd from the same flat folder, so
+# the package is a single directory: <root>/<name>/<external><suffix> +
+# <name>-help.pd + metadata. Matches the layout the ossia/actions pd packager and
+# the Deken composite step expect (per-OS folders union file-by-file).
+function(avnd_create_pd_addon_package)
+  cmake_parse_arguments(AVND "" "NAME;SOURCE_PATH;PACKAGE_ROOT" "EXTERNALS;SUPPORT" ${ARGN})
+  if(NOT AVND_EXTERNALS)
+    return()
+  endif()
+
+  set(_pkg "${AVND_PACKAGE_ROOT}/${AVND_NAME}")
+  set(_pkg_target "${AVND_NAME}_pd_package")
+  add_custom_target(${_pkg_target} ALL DEPENDS ${AVND_EXTERNALS})
+
+  if(AVND_SOURCE_PATH)
+    avnd_packaging_copy_metadata("${_pkg}" "${AVND_SOURCE_PATH}" "${AVND_NAME}")
+  endif()
+
+  foreach(_external ${AVND_EXTERNALS})
+    add_custom_command(TARGET ${_external} POST_BUILD
+      COMMAND ${CMAKE_COMMAND} -E make_directory "${_pkg}"
+      COMMAND ${CMAKE_COMMAND} -E copy "$<TARGET_FILE:${_external}>" "${_pkg}/"
+      COMMENT "Packaging Pd external: ${_external}"
+      VERBATIM)
+
+    get_target_property(_pd_help ${_external} AVND_PD_HELP)
+    if(_pd_help)
+      # Interactive help patch (avnd_generate_help). Best-effort: a missing help
+      # patch (some toolchains) must not fail packaging.
+      if(TARGET "${_external}_help")
+        add_dependencies("${_external}" "${_external}_help")
+      endif()
+      get_property(_pkgdir GLOBAL PROPERTY AVND_PACKAGING_DIR)
+      add_custom_command(TARGET ${_external} POST_BUILD
+        COMMAND ${CMAKE_COMMAND}
+          "-DSRC=${CMAKE_BINARY_DIR}/${_pd_help}" "-DDST=${_pkg}"
+          -P "${_pkgdir}/avendish.packaging.copy_optional.cmake"
+        VERBATIM)
+    endif()
+  endforeach()
+
+  # SUPPORT libs sit next to the externals (Pd's loader searches the external's
+  # own folder for siblings).
+  foreach(_support ${AVND_SUPPORT})
+    add_custom_command(TARGET ${_pkg_target} POST_BUILD
+      COMMAND ${CMAKE_COMMAND} -E make_directory "${_pkg}"
+      COMMAND ${CMAKE_COMMAND} -E copy_if_different "${_support}" "${_pkg}/"
+      VERBATIM)
+  endforeach()
+endfunction()
+
+# --- Python (addon) ---------------------------------------------------------
+#
+# avnd_create_python_addon_package(
+#   NAME <addon-name> SOURCE_PATH <dir> PACKAGE_ROOT <dir>
+#   EXTERNALS <target> ...      # the *_python module targets (py<c_name>.so/.pyd)
+#   [SUPPORT <file> ...])
+#
+# Layout: <root>/<name>/py<c_name>.<so|pyd> + <root>/<name>/__init__.py (re-exports
+# every compiled port) + <root>/<name>/examples/<c_name>_example.py + metadata.
+# Mirrors the ossia/actions python packager (which synthesizes the same __init__).
+function(avnd_create_python_addon_package)
+  cmake_parse_arguments(AVND "" "NAME;SOURCE_PATH;PACKAGE_ROOT" "EXTERNALS;SUPPORT" ${ARGN})
+  if(NOT AVND_EXTERNALS)
+    return()
+  endif()
+
+  set(_pkg "${AVND_PACKAGE_ROOT}/${AVND_NAME}")
+  set(_pkg_target "${AVND_NAME}_python_package")
+  add_custom_target(${_pkg_target} ALL DEPENDS ${AVND_EXTERNALS})
+
+  if(AVND_SOURCE_PATH)
+    avnd_packaging_copy_metadata("${_pkg}" "${AVND_SOURCE_PATH}" "${AVND_NAME}")
+  endif()
+
+  # Loader shim: re-export every py<port> module as an attribute of the package,
+  # tolerating a single failed import. Addon-independent, written once.
+  file(WRITE "${_pkg}/__init__.py"
+"# Auto-generated by avendish (avnd_create_python_addon_package).
+# Re-exports every compiled avendish port (py<port>) as a package attribute.
+import importlib as _importlib
+import glob as _glob
+import os as _os
+
+_here = _os.path.dirname(__file__)
+for _f in _glob.glob(_os.path.join(_here, 'py*.*')):
+    _ext = _os.path.splitext(_f)[1].lower()
+    if _ext not in ('.so', '.pyd'):
+        continue
+    _name = _os.path.splitext(_os.path.basename(_f))[0]
+    try:
+        globals()[_name] = _importlib.import_module('.' + _name, package=__name__)
+    except Exception as _exc:
+        import sys as _sys
+        print('avendish: failed to import {}: {}'.format(_name, _exc), file=_sys.stderr)
+
+del _importlib, _glob, _os
+")
+
+  foreach(_external ${AVND_EXTERNALS})
+    add_custom_command(TARGET ${_external} POST_BUILD
+      COMMAND ${CMAKE_COMMAND} -E make_directory "${_pkg}"
+      COMMAND ${CMAKE_COMMAND} -E copy "$<TARGET_FILE:${_external}>" "${_pkg}/"
+      COMMENT "Packaging Python module: ${_external}"
+      VERBATIM)
+
+    get_target_property(_py_example ${_external} AVND_PYTHON_EXAMPLE)
+    if(_py_example)
+      if(TARGET "${_external}_help")
+        add_dependencies("${_external}" "${_external}_help")
+      endif()
+      get_property(_pkgdir GLOBAL PROPERTY AVND_PACKAGING_DIR)
+      add_custom_command(TARGET ${_external} POST_BUILD
+        COMMAND ${CMAKE_COMMAND}
+          "-DSRC=${CMAKE_BINARY_DIR}/${_py_example}" "-DDST=${_pkg}/examples"
+          -P "${_pkgdir}/avendish.packaging.copy_optional.cmake"
+        VERBATIM)
+    endif()
+  endforeach()
+
+  foreach(_support ${AVND_SUPPORT})
+    add_custom_command(TARGET ${_pkg_target} POST_BUILD
+      COMMAND ${CMAKE_COMMAND} -E make_directory "${_pkg}"
+      COMMAND ${CMAKE_COMMAND} -E copy_if_different "${_support}" "${_pkg}/"
+      VERBATIM)
+  endforeach()
+endfunction()
+
 # --- TouchDesigner ----------------------------------------------------------
 #
 # avnd_create_touchdesigner_package(
@@ -356,6 +491,12 @@ function(avnd_addon_package)
     set(AVND_PACKAGE_ROOT "${CMAKE_BINARY_DIR}/package")
   endif()
 
+  # Mark that an addon has assembled its packages explicitly, so the default
+  # auto-packaging in avnd_addon_finalize() stands down (an explicit call is how
+  # addons pass SUPPORT libs / a custom PACKAGE_ROOT; auto-packaging again would
+  # duplicate POST_BUILD copies and miss the SUPPORT).
+  set_property(GLOBAL PROPERTY AVND_ADDON_PACKAGE_INVOKED 1)
+
   foreach(_backend ${AVND_BACKENDS})
     string(TOLOWER "${_backend}" _backend)
     if(_backend STREQUAL "td")
@@ -375,6 +516,20 @@ function(avnd_addon_package)
         PACKAGE_ROOT "${AVND_PACKAGE_ROOT}"
         EXTERNALS ${_externals}
         SUPPORT ${AVND_SUPPORT})
+    elseif(_backend STREQUAL "pd")
+      avnd_create_pd_addon_package(
+        NAME "${AVND_NAME}"
+        SOURCE_PATH "${AVND_SOURCE_PATH}"
+        PACKAGE_ROOT "${AVND_PACKAGE_ROOT}"
+        EXTERNALS ${_externals}
+        SUPPORT ${AVND_SUPPORT})
+    elseif(_backend STREQUAL "python")
+      avnd_create_python_addon_package(
+        NAME "${AVND_NAME}"
+        SOURCE_PATH "${AVND_SOURCE_PATH}"
+        PACKAGE_ROOT "${AVND_PACKAGE_ROOT}"
+        EXTERNALS ${_externals}
+        SUPPORT ${AVND_SUPPORT})
     elseif(_backend STREQUAL "touchdesigner")
       avnd_create_touchdesigner_package(
         NAME "${AVND_NAME}"

cmake/avendish.pd.cmake

@@ -130,6 +130,9 @@ function(avnd_make_pd)
 
   avnd_common_setup("${AVND_TARGET}" "${AVND_FX_TARGET}")
 
+  # Register for avnd_addon_package() (the addon-wide packaging orchestrator).
+  set_property(GLOBAL APPEND PROPERTY AVND_ALL_PD_EXTERNALS ${AVND_FX_TARGET})
+
   # Ship a help patch: <c_name>-help.pd next to the external (Pd finds it on the
   # path). Use the explicit HELP_PATCH override if given, else auto-generate.
   avnd_generate_help(

cmake/avendish.python.cmake

@@ -78,6 +78,9 @@ function(avnd_make_python)
 
   avnd_common_setup("${AVND_TARGET}" "${AVND_FX_TARGET}")
 
+  # Register for avnd_addon_package() (the addon-wide packaging orchestrator).
+  set_property(GLOBAL APPEND PROPERTY AVND_ALL_PYTHON_EXTERNALS ${AVND_FX_TARGET})
+
   # Usage example next to the module.
   avnd_generate_help(
     FX_TARGET     "${AVND_FX_TARGET}"