pixi.toml

[workspace]
channels = ["conda-forge"]
platforms = ["win-64", "linux-64", "osx-64"]

[feature.lint.tasks]
# Local dev: rewrite the tree in place. Exclusions are config-driven (pyproject's [tool.black] via
# .gitignore, [tool.ruff] exclude, [tool.isort] skip), so these are safe to point at ".".
lint = { cmd = "black . --config pyproject.toml && ruff check . --fix && isort .", description = "Format + lint Python in place" }
# The CI gate — NOT `lint`. black, `ruff check --fix` and isort all MUTATE and exit 0, so a lint job
# running `lint` reformats the runner's throwaway checkout and passes unconditionally: it cannot
# fail, whatever the PR contains. Same tools, same config, same order — check mode reports instead
# of rewriting.
lint-check = { cmd = "black . --check --config pyproject.toml && ruff check . && isort . --check-only", description = "CI gate: fail on any unformatted/unlinted Python" }
flat = { cmd = "python src/flatbuffers/update_flatbuffers.py && pixi run lint", cwd = "./" }

json-code-gen-py = { cmd = [
    "datamodel-codegen",
    "--input", "src/gltf_extension_schema",
    "--input-file-type", "jsonschema",
    "--output", "src/ada/extension",
    "--output-model-type", "pydantic_v2.BaseModel"], cwd = "./" }
# Generate the adacpp C++ header for ADA_EXT_data from the same schema (sibling adacpp checkout).
json-code-gen-cpp = { cmd = ["python", "scripts/codegen_ada_ext_cpp.py"], cwd = "./" }

[feature.docs.tasks]
docs = { cmd = "cd docs && sphinx-build -b html -v -D nbsphinx_execute=auto -d _build/doctrees . _build/html", depends-on = ["fea-doc"], env = { "PYTHONPATH" = "$PIXI_PROJECT_ROOT/src" } }
serve = { cmd = "python docs/main.py", env = { "PYTHONPATH" = "$PIXI_PROJECT_ROOT/src" }, depends-on = ["docs"] }
fea-doc = { cmd = "python -m paradoc.cli_app build verification --no-cache", env = { "PYTHONPATH" = "$PIXI_PROJECT_ROOT/src", "ADAPY_VERIFICATION_REGEN_ASSETS" = "1" } }
fea-doc-cached = { cmd = "python -m paradoc.cli_app build verification", env = { "PYTHONPATH" = "$PIXI_PROJECT_ROOT/src" } }
fea-doc-inspect = { cmd = "python -m paradoc.cli_app build verification --inspect --no-compile", env = { "PYTHONPATH" = "$PIXI_PROJECT_ROOT/src" } }
serve-fea = { cmd = "python -m http.server 8765 --bind 127.0.0.1 --directory docs/_static/fea-report" }

[feature.tests.tasks]
# `--with-deps` omitted on purpose — it shells out to `sudo apt` and
# breaks in non-interactive shells. Run `pixi run -e tests playwright
# install-deps chromium` once by hand if a test reports a missing lib.
pre-install = { cmd = "mkdir -p $PIXI_PROJECT_ROOT/.temp && playwright install chromium && touch $PIXI_PROJECT_ROOT/.temp/playwright-browsers.stamp", outputs = [".temp/playwright-browsers.stamp"] }

test = { cmd = "pytest tests --ignore=tests/profiling --ignore=tests/fem --ignore=tests/comms/rest --durations=0", depends-on = ["pre-install"], env = { "PYTHONPATH" = "$PIXI_PROJECT_ROOT/src" } }
test-core = { cmd = "pytest tests/core --durations=0", env = { "PYTHONPATH" = "$PIXI_PROJECT_ROOT/src" } }
test-full = { cmd = "pytest tests/full --durations=0", env = { "PYTHONPATH" = "$PIXI_PROJECT_ROOT/src" } }
test-cov = { cmd = "pytest tests --ignore=tests/profiling --ignore=tests/fem --ignore=tests/comms/rest --cov=src/ada --cov-report=html --cov-report=term --durations=0", depends-on = ["pre-install"], env = { "PYTHONPATH" = "$PIXI_PROJECT_ROOT/src" } }

# CAD-backend abstraction regression gate (dap plan/v3). bench-cad-save
# captures a baseline before Phase 1; bench-cad-compare re-runs after and
# fails on a >10% mean regression. Baselines live in .benchmarks/.
bench-cad = { cmd = "pytest tests/profiling/test_cad_backend_bench.py --benchmark-only -q", env = { "PYTHONPATH" = "$PIXI_PROJECT_ROOT/src" } }
bench-cad-save = { cmd = "pytest tests/profiling/test_cad_backend_bench.py --benchmark-only --benchmark-save=phase0 -q", env = { "PYTHONPATH" = "$PIXI_PROJECT_ROOT/src" } }
bench-cad-compare = { cmd = "pytest tests/profiling/test_cad_backend_bench.py --benchmark-only --benchmark-compare --benchmark-compare-fail=mean:10% -q", env = { "PYTHONPATH" = "$PIXI_PROJECT_ROOT/src" } }

[feature.fem.tasks]
# Full non-REST suite across BOTH CAD backends, report-both. Orchestrated by
# scripts/run_test_all.sh: it runs the ada-cpp leg (`pixi run -e tests-adacpp
# test-all`) and the pythonocc leg (pytest in this fem env) independently —
# neither aborts the other — then exits non-zero if either had failures.
# pyocc runs the entire non-REST suite incl. the playwright frontend e2e
# tests (fem env now carries the `tests` feature). comms/rest is excluded:
# it needs the viewer-api stack (its own `test-rest` task / env).
# A plain pixi depends-on can't do report-both (it fails fast), hence the
# wrapper. This `test-all` is gated to the fem env by feature membership.
test-all = { cmd = "bash scripts/run_test_all.sh", depends-on = ["pre-install"], env = { "PYTHONPATH" = "$PIXI_PROJECT_ROOT/src" } }
test-fem = { cmd = "pytest tests/fem --durations=0", env = { "PYTHONPATH" = "$PIXI_PROJECT_ROOT/src" } }
test-basic-fem = { cmd = "python basic_fem.py", env = { "PYTHONPATH" = "$PIXI_PROJECT_ROOT/src" }, cwd = "examples" }
test-fem-viz = { cmd = "pytest tests/fem/visualization --durations=0", env = { "PYTHONPATH" = "$PIXI_PROJECT_ROOT/src" } }

print-paths = { cmd = "python -c \"import sys, os; print('\\n'.join(sys.path + os.environ.get('PYTHONPATH', '').split(os.pathsep)))\"" }

[feature.prod.tasks]
topo-model-demo = { cmd = "python topo_model_demo.py", env = { "PYTHONPATH" = "$PIXI_PROJECT_ROOT/src" }, cwd = "examples" }

[feature.frontend.tasks]
npm = { cmd = "npm", cwd = "./src/frontend" }
winstall = { cmd = "npm install", cwd = "./src/frontend", outputs = ["$PIXI_PROJECT_ROOT/src/frontend/node_modules"] }
wdev = { cmd = "npm run dev", cwd = "./src/frontend", depends-on = ["winstall"] }
wbuild = { cmd = "npm run build", cwd = "./src/frontend", depends-on = ["winstall"] }
# Build the pyodide ada-py wheel into the SPA's public/wheels so the dev
# server and build serve it at /wheels/ for the in-browser FEM/SAT stacks.
wheel-pyodide = { cmd = "python tools/build_pyodide_adapy_wheel.py src/frontend/public/wheels" }
fdepcheck = { cmd = "depcheck", cwd = "./src/frontend", depends-on = ["winstall"] }

json-code-gen-ts = { cmd = [
    "npx", "--yes", "-p", "json-schema-to-typescript", "json2ts",
    "--input","design_and_analysis_extension.schema.json",
    "--output","$PIXI_PROJECT_ROOT/src/frontend/src/extensions/design_and_analysis_extension.d.ts"], depends-on = ["json-code-gen-py"], env = { "npm_config_cache" = "$PIXI_PROJECT_ROOT/temp/npm_config" }, cwd="src/gltf_extension_schema/" }

[feature.profile.tasks]
benchmark-profile = { cmd = "python scripts/benchmark_profile.py", env = { "PYTHONPATH" = "$PIXI_PROJECT_ROOT/src" } }
scalene = { cmd = "scalene --json -m pytest ./tests/profiling --outfile=profile.json", env = { "PYTHONPATH" = "$PIXI_PROJECT_ROOT/src" } }
cprofile = { cmd = "python -m cProfile -o profile.prof -m pytest ./tests/profiling", env = { "PYTHONPATH" = "$PIXI_PROJECT_ROOT/src" } }
pyprofile = { cmd = "pyinstrument -m pytest ./tests/profiling", env = { "PYTHONPATH" = "$PIXI_PROJECT_ROOT/src" } }
pyprofile-all = { cmd = "pyinstrument -m pytest ./tests", env = { "PYTHONPATH" = "$PIXI_PROJECT_ROOT/src" } }
pyprofile-html = { cmd = "pyinstrument -r html -o profile_profiling_tests.html -m pytest ./tests/profiling", env = { "PYTHONPATH" = "$PIXI_PROJECT_ROOT/src" } }
pyprofile-html-all = { cmd = "pyinstrument -r html -o profile_all_tests.html -m pytest ./tests", env = { "PYTHONPATH" = "$PIXI_PROJECT_ROOT/src" } }

[environments]
prod = { features = ["prod", "pyocc", "desktop"], solve-group = "prod", no-default-feature = true }
lint = { features = ["lint"], no-default-feature = true }
profile = { features = ["profile", "prod", "pyocc", "desktop"], solve-group = "prod", no-default-feature = true }
frontend = { features = ["frontend"], no-default-feature = true }
jupyterlite = { features = ["jupyterlite"], no-default-feature = true }
ifc-validation = { features = ["ifc-validation"], no-default-feature = true }
tests-core = { features = ["tests-core"], no-default-feature = true }
test-pyodide = { features = ["test-pyodide"], no-default-feature = true }
tests = { features = ["tests", "tests-core", "prod", "pyocc", "desktop"], solve-group = "prod", no-default-feature = true }
# Same as `tests` but swaps the pythonocc CAD backend (`pyocc`) for the
# native ada-cpp backend (`adacpp`), which sets ADAPY_CAD_BACKEND=adacpp.
# Own solve-group: ada-cpp's occt closure must not be forced onto the
# pythonocc-pinned `prod` group. Run with: pixi run -e tests-adacpp test
tests-adacpp = { features = ["adacpp", "tests", "tests-core", "prod", "desktop"], solve-group = "adacpp", no-default-feature = true }
# Same as tests-adacpp but bridges a bleeding-edge adacpp via PYTHONPATH (../adacpp/build/dist)
# instead of the conda-installed ada-cpp — see [feature.adacpp-dev.activation.env]. Assemble the
# bridge first with `pixi run build-dist` in the adacpp repo. The adacpp-dev feature adds no
# dependencies, so this reuses the adacpp solve-group (no extra solve).
tests-adacpp-dev = { features = ["adacpp", "adacpp-dev", "tests", "tests-core", "prod", "desktop"], solve-group = "adacpp", no-default-feature = true }
fem-deps = { features = ["fem-deps", "prod", "pyocc", "tests-core"], no-default-feature = true }
# `tests` feature added so the pyocc side of `test-all` can run the whole
# non-REST suite, including the playwright frontend e2e tests (which live
# only under tests/full/frontend and need the `tests` feature's playwright).
fem = { features = ["fem", "tests", "prod", "pyocc", "desktop", "tests-core", "fem-deps"], no-default-feature = true }
docs = { features = ["docs", "prod", "pyocc", "desktop", "fem-deps", "tests-core"], no-default-feature = true }
viewer-api = { features = ["viewer-api", "prod", "pyocc", "adacpp-runtime"], solve-group = "prod", no-default-feature = true }
# Slim runtime for the Dockerfile.viewer image — no `prod` so the
# occt/pythonocc/numpy closure stays out.
viewer-api-slim = { features = ["viewer-api", "viewer-slim"], no-default-feature = true }
viewer-api-tests = { features = ["viewer-api", "tests-core", "prod", "pyocc"], solve-group = "prod", no-default-feature = true }
# Same as viewer-api-tests but adds ada-cpp (adacpp-runtime) so the REST streaming-path tests run
# against the AdacppBackend (tessellate_stream / NGEOM libtess2) instead of the OCC object-path
# fallback. Mirrors the production `viewer-api` env's closure (pyocc + adacpp-runtime share occt
# 7.9.3, solve-group prod) — NOT the `adacpp` feature (separate solve-group, drops pyocc by design).
viewer-api-tests-adacpp = { features = ["viewer-api", "tests-core", "prod", "pyocc", "adacpp-runtime"], solve-group = "prod", no-default-feature = true }
meshio-bridge = { features = ["meshio-bridge", "prod", "pyocc", "desktop"], solve-group = "prod", no-default-feature = true }
meshio-bridge-tests = { features = ["meshio-bridge", "tests-core", "prod", "pyocc", "desktop"], solve-group = "prod", no-default-feature = true }

[feature.jupyterlite.dependencies]
jupyterlite-core = "*"

# Official buildingSMART-aligned IFC validation, kept in a dedicated feature so
# its closure stays out of the main envs. Covers the OFFLINE, installable parts
# of the buildingSMART IFC Validation Service (https://github.com/buildingSMART/validate):
#   * Syntax check       — ifcopenshell.open + log_internal_cpp_errors
#   * Schema check       — ifcopenshell.validate (attribute/select/inverse rules)
#   * Express/where-rules — ifcopenshell.validate(..., express_rules=True)
#   * IDS check (opt-in)  — ifctester, when an .ids is passed to the task
# The service's Gherkin normative rules (buildingSMART/ifc-gherkin-rules) are a
# git repo of behave feature files, not a pip package, and pull a heavy closure
# (Django/pyproj/rtree/shapely); they are deliberately NOT wired here — see
# scripts/validate_ifc.py for how to run them separately.
#
# ifctester (the optional IDS pillar) is PyPI-only and NOT declared here on
# purpose: it depends on `ifcopenshell`, and the conda-forge ifcopenshell ships
# no .dist-info, so pixi/uv can't see it as satisfying that pypi requirement and
# tries to pull a second (pypi) ifcopenshell — which has no wheel for this
# manylinux baseline, breaking the solve. The env therefore stays conda-only and
# resolves cleanly; enable IDS validation when needed with:
#     pixi run -e ifc-validation python -m pip install --no-deps ifctester
[feature.ifc-validation.dependencies]
python = "3.12.*"
ifcopenshell = "*"
# ifcopenshell's generated EXPRESS where-rule modules `import pytest` (they use
# pytest.approx for numeric tolerance), so express_rules=True needs pytest present.
pytest = "*"

[feature.ifc-validation.tasks]
ifc-validate = { cmd = "python scripts/validate_ifc.py", env = { "PYTHONPATH" = "$PIXI_PROJECT_ROOT/src" } }

[feature.meshio-bridge.dependencies]
meshio = "*"

# pythonocc-core CAD backend (OccBackend). Factored out of `prod` so a
# single environment can swap it for the `adacpp` feature — see
# `tests-adacpp` below. Every environment that historically got the OCC
# backend via `prod` now lists `pyocc` explicitly.
# novtk: default occt builds link VTK + X libs we don't render through.
# pythonocc-core's build string must match occt's or the solver picks the
# vtk-enabled occt. Pinned to 7.9.3 to share the exact OCCT version with
# ada-cpp (which links the same conda-forge occt) — identical TopoDS ABI
# makes the from_topods_pointer bridge between the two backends safe.
# See dap plan/v3 Phase 7.
[feature.pyocc.dependencies]
pythonocc-core = { version = "7.9.3.*", build = "novtk_*" }
occt = { version = "7.9.3.*", build = "novtk_*" }

# ada-cpp as a *runtime library alongside pyocc* — no ADAPY_CAD_BACKEND flip (unlike
# the `adacpp` feature). The conversion worker (viewer-api env) needs ada-cpp present
# so the default libtess2 STEP→GLB pipeline can run; pyocc stays the default backend
# for every other path (IFC/XML/FEM, occ-builtin fallback). Shares occt 7.9.3 with
# pyocc (see above) so both coexist in one env.
[feature.adacpp-runtime.dependencies]
ada-cpp = "0.20.0.*"

# ada-cpp CAD backend (AdacppBackend) — native CPython build of the
# wasm-capable kernel. Brings its own occt 7.9.3 + gmsh + ifcopenshell,
# and deliberately does NOT pull pythonocc-core, so an environment with
# `adacpp` and without `pyocc` exercises adacpp as the sole CAD backend
# (no pythonocc fallback by design).
[feature.adacpp.dependencies]
# 0.10.x carries the NGEOM libtess2 tessellator + meshopt EXT-compression codecs
# (cad.meshopt_encode_*) + ifc-taxonomy kernel; adapy's meshopt/NGEOM paths need it. 0.11 adds
# the native STEP/IFC B-rep emitters + step_parity. 0.12 adds SAT pcurve trim records (kind-6
# tail), plain-SHAPE_REPRESENTATION product linkage, $-surface face recovery, the sew face-count
# cap, and the cgroup-aware concurrency clamp — adapy's pcurve/parity paths here require it.
# 0.13 adds the pure-C++ IFC reader/writer + zero-copy NGEOM streams (lazy ShapeStore), the cone
# semi-angle plane-angle-unit drop fix, and tessellation perf work; adapy's native import/stream
# paths graduate off the branch overlay onto this release. 0.14 adds tess_tracks() — the track
# vocabulary adacpp declares and ada.cad.registry discovers — plus boundary pinning on by default
# and the watertight `cdt` track. REQUIRED, not merely nice: the discovery tests skip outright
# against an older ada-cpp, so a lower pin makes them silently vacuous. 0.15 adds
# imprint_planar_faces plus win-64 build and cad-API-generator encoding fixes. 0.16
# adds native OCC-free STEP/IFC→GLB with tessellation tracks and colour/curved-surface
# fidelity; 0.16.1 fixes per-face STEP colours without --face-regions plus CLI positional
# args and pipeline validation. 0.18 adds AP242 mapped instancing, closed-B-spline
# tessellation fixes, and the NGEOM record-stream emitters (stream_ngeom_to_step/ifc/glb/mesh
# + ngeom_to_ifc_body_spf) — adapy's native Genie-XML export legs call these directly. 0.19 adds
# the thick-shell cap<->wall seam-weld (Libtess2Opts::cdt_full_patch, env ADA_TESS_WT_CDT_FULL_PATCH,
# honoured by the record streamer via ngeom_tess_params too) that the converter's curved-shell
# auto-enable wiring drives — REQUIRED: without it hull/gxml thick shells render with cracked seams.
# 0.20 adds the native is_planar_face verb (GeomLib_IsPlanarSurface, PR #46) so a loft compile on
# the adacpp backend classifies ruled corner panels vs planar caps natively — restores curved-corner
# loft parity without routing through a local OccBackend (the loft_backend() OCC workaround).
ada-cpp = "0.20.0.*"

[feature.adacpp.activation.env]
ADAPY_CAD_BACKEND = "adacpp"

# Bleeding-edge adacpp bridge: prepend ../adacpp/build/dist (the importable package assembled
# by `pixi run build-dist` in the adacpp repo) so its freshly built native .so shadows the
# conda-installed ada-cpp. Also keeps src/ on the path so `ada` resolves. Used by the
# tests-adacpp-dev environment; only applies to commands that don't set PYTHONPATH inline
# (run scripts directly, e.g. `pixi run -e tests-adacpp-dev python prototypes/...`).
[feature.adacpp-dev.activation.env]
PYTHONPATH = "$PIXI_PROJECT_ROOT/src:$PIXI_PROJECT_ROOT/../adacpp/build/dist"

# Windows takes ';' as the PYTHONPATH separator, not ':'. Without this override the line above
# reaches python as ONE path ("C:\...\src:C:\...\build\dist"), which exists nowhere — so `ada`
# fails to import AND the dev adacpp silently loses to the conda-installed ada-cpp in
# site-packages, i.e. the bridge this env exists for quietly doesn't happen.
[feature.adacpp-dev.target.win-64.activation.env]
PYTHONPATH = "%PIXI_PROJECT_ROOT%/src;%PIXI_PROJECT_ROOT%/../adacpp/build/dist"

[feature.adacpp.tasks]
# ada-cpp leg of `test-all`. Runs the whole non-REST suite against the native
# ada-cpp CAD backend. Excludes tests/fem/visualization (needs medcoupling,
# which is in fem-deps and not in the tests-adacpp env). This task is gated to
# the tests-adacpp env by feature membership: that env carries `adacpp` but not
# `fem`, while the fem env carries `fem` but not `adacpp`, so each env resolves
# `test-all` to exactly one definition (no recursion). The fem-env orchestrator
# chains into this via `pixi run -e tests-adacpp test-all`.
test-all = { cmd = "pytest tests --ignore=tests/comms/rest --ignore=tests/fem/visualization --durations=0", depends-on = ["pre-install"], env = { "PYTHONPATH" = "$PIXI_PROJECT_ROOT/src" } }

[feature.prod.dependencies]
python = "3.12.*"
bcf-client = "*"
numpy = "*"
hdf5 = "*"
h5py = "*"
ifcopenshell = "*"
python-gmsh = "*"
pyquaternion = "*"
trimesh = ">=5,<6"
websockets = ">=14"
pyparsing = "*"
flatbuffers = "*"
python-flatbuffers = "*"
lark = "*"
pillow = "*"
pydantic = "*"
# openpyxl backs ada.serialize.xlsx (+ topo_model excel_io / takeoff). It was
# previously only reaching users transitively; declare it explicitly so the
# runtime closure is self-contained.
openpyxl = "*"

# Notebook / rendering / static-export deps. Held separate from `prod`
# so the slim viewer-api / worker images don't ship the
# pygfx→wgpu→imgui→libopencv→ffmpeg closure (~260 MiB).
[feature.desktop.dependencies]
notebook = "*"
ipywidgets = "*"
jupyterlab = "*"
plotly = "*"
python-kaleido = ">=1.0.0"
pygfx = ">=0.16"
# pygfx 0.16 needs wgpu ≥ 0.21 (no more `wgpu.gui.offscreen`) and
# rendercanvas ≥ 2.0 for our offscreen path.
wgpu-py = ">=0.31"
rendercanvas = ">=2.6"
glfw = "==3.4"
pyglfw = "*"
send2trash = "*"

[feature.prod.target.win-64.activation.env]
PYTHONPATH="%PIXI_PROJECT_ROOT%/src"

[feature.fem-deps]
channels = ["conda-forge"]
[feature.fem]
channels = ["conda-forge"]
[feature.docs]
channels = ["conda-forge"]

[feature.fem-deps.dependencies]
calculix = "*"

[feature.fem-deps.target.linux-64.dependencies]
code-aster = ">=17.3.16"

[feature.tests-core.dependencies]
pytest = "*"
pytest-benchmark = "*"
pytest-asyncio = "*"
pytest-timeout = "*"
pytest-cov = "*"
paradoc = ">=0.6.0"
python-dotenv = "*"
watchdog = "*"

[feature.profile.dependencies]
pytest = "*"
pytest-benchmark = "*"
pytest-asyncio = "*"
pyinstrument = "*"

# Editable installs
[feature.tests.pypi-dependencies]
pytest-playwright = "*"

[feature.lint.dependencies]
black = "==24.4.2"
isort = "==5.13.2"
ruff = "==0.12.8"

flatbuffers = "==25.2.10"
python-flatbuffers = "==25.2.10"
datamodel-code-generator = "==0.30.1"

[feature.docs.dependencies]
sphinx = "*"
furo = "*"
myst-parser = "*"
nbsphinx = "*"
scipy = "*"
fastapi = "*"  # For the API docs
pandas = "*"

[feature.viewer-api.dependencies]
fastapi = "*"
uvicorn = "*"
obstore = "*"
nats-py = "*"
pydantic = "*"
python-flatbuffers = "*"
pyjwt = "*"
cryptography = "*"
httpx = "*"
asyncpg = "*"
psutil = "*"
croniter = "*"
# parallel gzip: derived outputs (obj/stl/step/ifc/xml/glb) are gzipped at-rest, and
# single-threaded zlib at level 9 was ~85% of the large-assembly STEP->obj job wall. pigz emits
# a standard gzip stream (Content-Encoding: gzip) across all cores — see storage._gzip_file.
pigz = "*"

# Pin the slim API image's python (it has no `prod`, so it would otherwise float to
# the newest cpython). Pinned to what it currently resolves to (3.14) for a
# reproducible image; kept separate from the full env's prod-pinned 3.12 to avoid a
# cross-feature python conflict.
[feature.viewer-slim.dependencies]
python = "3.14.*"

# PYTHONPATH must keep /opt/adacpp-overlay AHEAD of src so the deployed worker imports the
# branch-built adacpp (with the native stream_step_to_glb) rather than the conda base adacpp. The
# Dockerfile sets this env, but a task-level `env` REPLACES (not merges) it — so without the overlay
# prefix here the worker silently imported base adacpp, native_adacpp_available() returned False, and
# every adacpp-native STEP→GLB fell back to the slow libtess2 path. The path is absent in dev/CI and
# in the (overlay-less) viewer image, where Python just ignores the missing sys.path entry.
[feature.viewer-api.tasks]
viewer-api = { cmd = "python -m ada.comms.rest", env = { "PYTHONPATH" = "/opt/adacpp-overlay:$PIXI_PROJECT_ROOT/src" } }
viewer-worker = { cmd = "python -m ada.comms.rest.worker", env = { "PYTHONPATH" = "/opt/adacpp-overlay:$PIXI_PROJECT_ROOT/src" } }
test-rest = { cmd = "pytest tests/comms/rest --durations=0", env = { "PYTHONPATH" = "$PIXI_PROJECT_ROOT/src" } }
# Streaming-path REST coverage against the native ada-cpp backend: forces ADAPY_CAD_BACKEND=adacpp so
# merge-preview generate exercises tessellate_stream (NGEOM libtess2), not the OCC object-path fallback
# that test-rest hits in the (adacpp-less) viewer-api-tests env. Run in the viewer-api-tests-adacpp env.
# No Postgres needed — these tests use an in-memory fake store.
test-rest-adacpp = { cmd = "pytest tests/comms/rest -m adacpp_stream --durations=0", env = { "PYTHONPATH" = "$PIXI_PROJECT_ROOT/src", "ADAPY_CAD_BACKEND" = "adacpp" } }
ada = { cmd = "python -m ada_cli.main", env = { "PYTHONPATH" = "$PIXI_PROJECT_ROOT/src" } }
audit-fetch = { cmd = "python scripts/audit_fetch.py", env = { "PYTHONPATH" = "$PIXI_PROJECT_ROOT/src" } }
audit-repro = { cmd = "python scripts/audit_repro.py", env = { "PYTHONPATH" = "$PIXI_PROJECT_ROOT/src" } }
viewer-upload = { cmd = "python scripts/viewer_upload.py", env = { "PYTHONPATH" = "$PIXI_PROJECT_ROOT/src" } }
glb-face-classify = { cmd = "python scripts/glb_face_classify.py", env = { "PYTHONPATH" = "$PIXI_PROJECT_ROOT/src" } }

# NOTE: meshopt GLB compression (ada.visit.gltf.meshopt) no longer pulls the PyPI
# `meshoptimizer` package — it is sdist-only (no wheels) so every viewer/worker image
# tried to compile it from source and failed (no g++). The EXT_meshopt_compression
# encoders now live in adacpp (vendored meshoptimizer C source, cad.meshopt_encode_*);
# the compress path uses them when adacpp is present and gracefully skips otherwise.

[feature.frontend.dependencies]
nodejs = "24.*"
flatbuffers = "==25.2.10"

[feature.test-pyodide.dependencies]
nodejs = "*"

[feature.test-pyodide.tasks]
install-pyodide = { cmd = "npm install", cwd = "tools/pyodide-test", outputs = ["tools/pyodide-test/node_modules"] }
test-pyodide-cad = { cmd = "node test_pyodide_cad.js", cwd = "tools/pyodide-test", depends-on = ["install-pyodide"] }

[dependencies]
pixi-pycharm = ">=0.0.8,<0.0.9"

[feature.jupyterlite.tasks]
jl-init = { cmd = "jupyter lite init", cwd = "./src/jupyterlite" }
jl-build = { cmd = "jupyter lite build --output-dir=dist", cwd = "./src/jupyterlite" }
jl-serve = { cmd = "jupyter lite serve --output-dir=dist --port=8899", cwd = "./src/jupyterlite" }