facet-wrapped-group/Cargo.toml
[package]
name = "facet-wrapped-group"
description = "facett — the NON-core bundle groups of facet-wrapped (docs: docview + manual; model3d; sim: simview). The SAME source as facet-wrapped (its [lib] path points there), built with exactly one group feature, so each group is its own wasm bundle with its own manifest and the core bundle stays byte-identical."
version.workspace = true
edition.workspace = true
license.workspace = true
repository.workspace = true
publish = false
# THE SAME CRATE ROOT as facet-wrapped. facet-wrapped declares NO features (MEASURED
# 2026-09-29: an empty [features] table alone changes its release wasm), so the groups
# are declared HERE; the shared source gates on them on existing lines.
[lib]
name = "facet_wrapped_group"
path = "../facet-wrapped/src/lib.rs"
crate-type = ["cdylib", "rlib"]
[features]
# Build with EXACTLY ONE group feature. `group-only` drops the core registrations
# (each bundle's manifest lists only its own group's entries).
group-only = []
docs = ["group-only", "dep:facett-docview", "dep:facett-manual"]
model3d = ["group-only", "dep:facett-model3d", "dep:base64"]
# sim: the population Simulate viewer; its 3D cloud on the shared GPU cloud lane.
sim = ["group-only", "dep:facett-simview", "facett-simview/gpu"]
# The dependency tables below MUST equal facet-wrapped's (the shared source compiles
# against them) plus the group deps; `tests/same_dependencies.rs` holds that.
[dependencies]
# Renderer shared by the wrapped pipeline, plan and build-run components.
facett-flow = { path = "../facett-flow", version = "0.2.0", features = ["wgpu", "host"] }
facett-core = { path = "../facett-core", version = "0.3.0" }
serde = { version = "1", features = ["derive"] }
serde_json = { workspace = true }
# The adapters lower payloads into the components' own egui types (Color32/Pos2).
egui = { workspace = true }
# ── the wrapped components ───────────────────────────────────────────────────
# DATA-BEARING views (what korp and dwarves actually consume).
facett-table = { path = "../facett-table", version = "0.2.0" }
facett-icebergview = { path = "../facett-icebergview", version = "0.2.0" }
facett-stat = { path = "../facett-stat", version = "0.2.0" }
facett-plot = { path = "../facett-plot", version = "0.2.0" }
facett-matrix = { path = "../facett-matrix", version = "0.2.0" }
facett-timeline = { path = "../facett-timeline", version = "0.2.0" }
facett-log = { path = "../facett-log", version = "0.2.0" }
facett-console = { path = "../facett-console", version = "0.2.0" }
# MAP family — GPU LANES ON (row 3, 2026-09-05).
#
# What stood here said `facett-map3d` rode its DEFAULT features on purpose, because
# the CPU painter needs no wgpu RenderState from the host page. That was true and it
# was still wrong for THIS bundle: eframe here runs the wgpu backend on
# `Backends::BROWSER_WEBGPU`, so there IS a RenderState — and the components were
# projecting, culling and lighting every triangle in software behind it.
#
# The failure that hid it: `facet_backend()` returns the constant "webgpu" and
# `facet_canvas_api()` asks the canvas which context it holds. BOTH answered `webgpu`
# truthfully, on a build whose 3D map had no GPU renderer compiled in at all. A
# backend string in front of a software renderer is exactly the identity value LAW 2
# warns about — it cannot distinguish the two things it is read to distinguish.
#
# `default-features` stays ON for all three: their defaults carry the CPU painter,
# which is the reference path, the snapshot golden path, and the only thing left when
# `requestAdapter()` returns null. This adds a lane, it does not replace one.
#
# Held by `xtask/tests/wasm_bundle_has_gpu_features.rs`, which reads the edges out of
# cargo's own manifest parse rather than grepping this text.
# The 2-D map GPU lane (2026-09-28, owner ruling: a GPU always exists, and a map that
# paints on the CPU in a headful browser is a defect). `wgpu` puts `facett_map::gpu`
# (the GpuMapRenderer) in the binary; `map-wgpu` lets `OsmView` select it. The install
# is `install_gpu_lanes` in src/wasm.rs; `osm2d` and `map` call `with_gpu(true)`.
facett-map = { path = "../facett-map", version = "0.2.0", features = ["wgpu"] }
facett-geomap = { path = "../facett-geomap", version = "0.2.0", features = ["map-wgpu"] }
facett-map3d = { path = "../facett-map3d", version = "0.2.0", features = ["wgpu"] }
# GRAPH family — five surfaces, ONE payload contract (src/graph.rs).
# `wgpu` (2026-09-29): graph2d's nodes/edges on the shared GPU cloud lane.
facett-graph = { path = "../facett-graph", version = "0.2.0", features = ["wgpu"] }
facett-graph3d = { path = "../facett-graph3d", version = "0.2.0", features = ["wgpu"] }
# `gpu` lights graphnav's layout selector. Until 2026-09-18 this line named no
# feature, so the `cs_layout` compute shader that `facett-graphview/gpu` (two lines
# down) compiles INTO the bundle sat behind a selector that was not in the build, and
# every graph in a browser was laid out on one CPU thread (wasm32 has no
# `available_parallelism`, so gatling runs inline). The lane this selects on wasm is
# the NON-BLOCKING job on the host's borrowed device — `install_gpu_lanes` lends it.
# `wgpu` (2026-09-28) puts graphnav's node/edge cloud on the shared GPU cloud renderer;
# above `facett_graphnav::SCALE_NODES` it is the RESIDENT model (uploaded once, camera
# per frame). Without it every disc and edge was tessellated on the CPU every frame.
facett-graphnav = { path = "../facett-graphnav", version = "0.2.0", features = ["gpu", "wgpu"] }
facett-graphpan = { path = "../facett-graphpan", version = "0.2.0", features = ["wgpu"] }
# `gpu`, not `wgpu` — graphview spells its lane differently (vello on wgpu 29).
# `gpu-cloud` (2026-09-29): graphview's node/edge cloud on the shared renderer — measured on
# the t14s headless: `legibility.gpu_cloud: false` with `gpu` alone, which compiles the lane out.
facett-graphview = { path = "../facett-graphview", version = "0.2.0", features = ["gpu", "gpu-cloud"] }
# The size + generator (lane F, 2026-10-02): facett-demo's generators, lowerings, GenTab and
# Universe, as a library — the `{"generate": …}` seam (src/generated.rs). `cloud` puts the
# Universe on the resident GPU cloud; the graph/graph3d lanes are already on above.
facett-graphgen = { path = "../facett-graphgen", version = "0.2.0", features = ["cloud", "graph-wgpu", "graph3d-wgpu", "graph-layout-gpu"] }
# OPS / pipeline views — the surfaces korp and dwarves put a running system on.
facett-plandag = { path = "../facett-plandag", version = "0.2.0", features = ["wgpu"] }
facett-security = { path = "../facett-security", version = "0.2.0" }
facett-pipeline = { path = "../facett-pipeline", version = "0.2.0", features = ["wgpu"] }
facett-jobview = { path = "../facett-jobview", version = "0.2.0" }
facett-syschart = { path = "../facett-syschart", version = "0.2.0" }
facett-kanban = { path = "../facett-kanban", version = "0.2.0" }
facett-gantt = { path = "../facett-gantt", version = "0.2.0" }
# `progress` (2026-09-29): labelled bulk-load progress, pure egui + serde.
facett-pop = { path = "../facett-pop", version = "0.2.0" }
# The forge family (`src/forge.rs`, 2026-09-29): pure egui + serde.
facett-cicd = { path = "../facett-cicd", version = "0.2.0" }
facett-brokkrview = { path = "../facett-brokkrview", version = "0.2.0", features = ["wgpu"] }
facett-holger = { path = "../facett-holger", version = "0.2.0" }
facett-releaseview = { path = "../facett-releaseview", version = "0.2.0" }
facett-binview = { path = "../facett-binview", version = "0.2.0" }
facett-coderoom-view = { path = "../facett-coderoom-view", version = "0.2.0" }
facett-fleet-view = { path = "../facett-fleet-view", version = "0.2.0" }
# `buildspace`: the evaluated feature axis (FeatureAxis → GaloisPane). Reaches edda's
# nornir-build-thing / nornir-feature-graph by path like facett-buildthing does; wasm32-clean.
facett-buildthing = { path = "../facett-buildthing", version = "0.2.0" }
# `facett-gantt` schedules on real calendar dates, so the adapter parses ISO
# `YYYY-MM-DD` into the `chrono::NaiveDate` its `Task` takes.
chrono = { version = "0.4", default-features = false, features = ["std"] }
facett-lineage = { path = "../facett-lineage", version = "0.2.0" }
facett-tabbar = { path = "../facett-tabbar", version = "0.2.0" }
facett-helix = { path = "../facett-helix", version = "0.2.0" }
# The chart/grid/calendar/card family (`src/charts.rs`, added 2026-09-28). All pure
# egui + serde (+ chrono, already here), wasm-clean.
facett-grid = { path = "../facett-grid", version = "0.2.0" }
facett-plotters = { path = "../facett-plotters", version = "0.2.0" }
facett-cfd = { path = "../facett-cfd", version = "0.2.0" }
facett-calendar = { path = "../facett-calendar", version = "0.2.0" }
facett-card = { path = "../facett-card", version = "0.2.0" }
# Arrow — `icebergview` takes RecordBatch frames, so the adapter builds them.
arrow-array = "59"
arrow-schema = "59"
# The wasm boundary — pulled ONLY for wasm32 so the host rlib + its tests stay light.
# eframe runs the **wgpu** backend in the browser, which on wasm32 targets the
# browser's WebGPU (`navigator.gpu`) — NOT WebGL. facet-wrapped was the last facett
# surface still on the glow/WebGL path; this is the port.
#
# The backend MASK and the eframe wgpu configuration are NOT restated here. They come
# from the one policy in `facett-core` (`preferred_backends()` / `facett_wgpu_options()`),
# which on wasm32 is `Backends::BROWSER_WEBGPU` — WebGPU and nothing else. Restating
# the choice locally is how this canvas would drift from every other facett surface,
# so the crate imports the decision instead of re-making it (LAW #5: reuse, don't twin).
# ── the group deps (optional; one group feature enables its own) ──
# docs: default-features = false keeps their 760 KB DejaVu font out (egui's Ubuntu-Light
# is the airgap face instead, read at run time — no second copy).
facett-docview = { path = "../facett-docview", version = "0.2.0", default-features = false, optional = true }
facett-manual = { path = "../facett-manual", version = "0.2.0", default-features = false, optional = true }
# model3d: the mesh travels as base64 inside the JSON payload.
facett-model3d = { path = "../facett-model3d", version = "0.2.0", optional = true }
# (2026-10-03, finish-bump) base64 0.22 -> 0.23 with the constellation; the
# `general_purpose::STANDARD` engine model.rs decodes with is unchanged.
base64 = { version = "0.23", optional = true }
# sim: the Simulate viewer (Arrow IPC over fetch).
facett-simview = { path = "../facett-simview", version = "0.2.0", optional = true }
[target.'cfg(target_arch = "wasm32")'.dependencies]
wasm-bindgen = "=0.2.127"
wasm-bindgen-futures = "0.4"
# `wgpu_no_default_features`, NOT `wgpu`. eframe's plain `wgpu` feature expands to
# `egui-wgpu/default`, which re-enables `wgpu/webgl` — the dead WebGL2 backend this
# crate exists to be rid of. eframe splits the two precisely so a host can take the
# renderer without the default backend set; the backends actually wanted come from
# facett-core's GPU lane below (and its `wgpu` dep's own defaults).
eframe = { version = "0.36", default-features = false, features = [
"default_fonts",
"wgpu_no_default_features",
] }
# The `wgpu` feature here is wasm32-only, so a host `cargo test` of the rlib still
# carries no GPU dependency edge and needs no GPU to run.
facett-core = { path = "../facett-core", version = "0.3.0", features = ["wgpu"] }
# NOTE: web-sys's own `Gpu`/`Navigator::gpu()` bindings sit behind
# `--cfg=web_sys_unstable_apis`, which would force an unstable RUSTFLAG on every
# build of this crate. The adapter pre-flight only needs to know whether
# `navigator.gpu` EXISTS, so it reads the property reflectively via `js-sys` and the
# crate keeps building on stable flags.
web-sys = { version = "0.3", features = ["HtmlCanvasElement", "Window", "Document", "Navigator", "Performance"] }
js-sys = "0.3"
console_error_panic_hook = "0.1"
log = "0.4"
[dev-dependencies]
# The core bundle's registry, to prove every entry is in exactly one group.
facet-wrapped = { path = "../facet-wrapped" }
# The recipe — entry → group is declared THERE (`BUNDLE_GROUPS[..].entries`), and
# `tests/groups.rs::group_entries_are_the_recipes` holds `groups::GROUP_ENTRIES` to it.
facett-build-thing = { path = "../facett-build-thing" }