Views

- type: table
  name: By brand
  order: [model, form, peak_torque, rated_torque, max_speed, mass, gear_ratio, voltage, od, length, buses, price]
  groupBy: { property: brand, direction: ASC }
  sort:
    - { property: peak_torque, direction: DESC }
  summaries: { peak_torque: Max, mass: Min, price: Min }

- type: pivot
  name: Benchmarks
  order: [variant]
  groupBy: { property: family }
  splitBy: [suite, test]
  value: { property: q_rms_mrad, summary: Median, display: dist }

- type: list
  name: Spec tree
  tree: { parent: parent }
  order: [title, state, tests, status]
  markers: none
  separator: "  "

- type: cards
  name: Actuators
  filters: 'category == "Actuator"'
  order: [model, logo, brand, peak_torque, mass]
  image: photo
  imageFit: contain
  imageAspectRatio: 0.8
  cardSize: 190
  lightbox: true
  caption: [brand, peak_torque]
  groupBy: { property: brand, direction: ASC }
  sort:
    - { property: peak_torque, direction: DESC }

- type: kanban
  name: By status
  order: [title, id, priority, areas]
  groupBy: { property: status }
  groupOrder: [backlog, ready, running, waiting, review, frontier, done, archived]
  columnWidth: 260
  sort:
    - { property: id, direction: ASC }

- type: chart
  name: Ashby · torque vs mass
  chart:
    mark: { type: point, filled: true, size: 22 }
    encoding:
      x: { field: mass, scale: { type: log } }
      y: { field: peak_torque, scale: { type: log } }
      color: { field: drivetrain }
  guides:
    - { envelope: drivetrain, shape: hull }
    - { indexLine: { slope: 1, through: median }, label: "constant N·m per g (median)" }
  hover: { image: photo, title: name, fields: [peak_torque, mass, torque_density, drivetrain, brand] }

- type: kpi
  name: KPIs
  groupBy: { property: label }
  groupOrder: [Successful picks per minute (SPPM), Computation time, Grasp success, Computation time p95, Bench score]
  sort:
    - { property: t, direction: ASC }
  kpi:
    value: { property: value }
    compare: { against: previous, better: better, neutral: 0.01 }
    spark: { x: t, y: value }

- type: calendar
  name: Month
  start: date
  title: title
  calendarView: month
  groupBy: { property: kind, direction: ASC }

- type: timeline
  name: Lanes by kind
  start: start
  end: end
  title: title
  color: release
  groupBy: { property: kind, direction: ASC }
  groupOrder: [release, integration, contract, main, lane]
  zoom: { min: PT10M, max: P14D }

- type: map
  name: Where sellers ship
  filters: 'relation == "ships to"'
  coordinates: coordinates
  markerColor: seller

- type: graph
  name: Wiring
  edges: { property: feeds, label: wire }
  layout: { algorithm: dagre, direction: LR }
  groupBy: { property: role, direction: ASC }
  groupOrder: [Power, CAN, Boards, Motors, Sensing]
  order: [model, v_load, current]

- type: record
  name: Part page
  record:
    sections:
      - { name: Torque and speed, properties: [peak_torque, rated_torque, torque_density, max_speed, rated_speed, rated_power] }
      - { name: Size, properties: [mass, od, length, gear_ratio, backlash] }
      - { name: Electrical, properties: [voltage, buses] }
      - { name: In the catalog, properties: [level, cited, cad, sim, measured, price, sellers] }

- type: compare
  name: Side by side
  order: [brand, level, drivetrain, buses, peak_torque, rated_torque, torque_density, max_speed, rated_speed, mass, gear_ratio, voltage, backlash, od, length, rated_power, price, sellers, measured, cited, cad, sim]
  compare:
    rows: [aifitlab-8541438771336, aifitlab-8542347853960, aifitlab-8682672160904, aifitlab-8649843966088]

- type: table
  name: Runs by week
  order: [run, started, model, env, attempts, successes, success_rate]
  groupBy: { property: started, by: week }
  sort:
    - { property: started, direction: ASC }
  display: { success_rate: bar }

- type: chart
  name: Runs per week
  chart:
    mark: bar
    encoding:
      x: { field: started, by: week, title: Week }
      y: { aggregate: count, title: Runs }
      color: { field: model }
  hover: { title: run, fields: [started, model, env, success_rate] }

- type: timeline
  name: By release
  start: start
  end: end
  title: title
  color: kind
  groupBy: { property: release, direction: ASC }
  subGroupBy: { property: kind, direction: ASC }
  zoom: { min: PT10M, max: P14D }

- type: calendar
  name: Release week
  filters: 'kind == "release"'
  start: date
  title: title
  calendarView: week

- type: kpi
  name: Pooled success by model
  groupBy: { property: model, direction: ASC }
  sort:
    - { property: round, direction: ASC }
  kpi:
    value: { property: successes, summary: Ratio, per: attempts }
    spark: { x: round, y: success_rate }
    gate: { min: 0.55 }

- type: table
  name: Leaderboard
  intro:
    text: |
      **Which model wins on each actuator, and is it twin-grade yet?** A card is an actuator's best model on the
      Oct 23 held-out tapes (× its floor), the delta its lead over the runner-up, the gate twin-grade's 1.5 ×, the
      spark its models worst → best. Below, every model ranked, **rolled up across actuators** (a cell's dots are the
      actuators it ran on); un-roll in **Roll up**, click a row for the actuators behind it.
    kpi:
      filters:
        and:
          - 'kind == "model"'
          - '!headline_x.isEmpty()'
      groupBy: { property: leader }
      kpi:
        value: { property: headline_x }
        compare: { against: runner_up_x, better: lower, neutral: 0.02 }
        spark: { x: rank_desc, y: headline_x }
        gate: { max: 1.5 }
  filters:
    and:
      - 'kind == "model"'
      - '!headline_x.isEmpty()'
  order: [variant, rung, headline_x, actuator, dataset_x, worst_class_x, floor_tape_x, twin_grade, n_runs]
  sort:
    - { property: headline_x, direction: ASC }
  display: { headline_x: dist }
  rollup: { keep: [variant], dims: [actuator, variant, model, ladder_step, rung, family] }
  record:
    sections:
      - { name: Model, properties: [variant, actuator, rung, family, description] }
      - { name: Error, properties: [headline_x, dataset_x, worst_class_x, floor_tape_x, twin_grade, benches] }
      - { name: Code, properties: [code_commit, code_hosted, code_path, readme] }

- type: table
  name: Parameters
  intro:
    text: |
      **What does each model run on?** One row per model and actuator with the terms it was fitted with, grouped
      under Friction, Capture, Drivetrain and Driver. The mark after a value is its basis (● measured, ○ an estimate
      whose fit the model card refused, C chosen); hover a value for its 95 % CI and source. "—" is a term the model
      does not run, with the reason on hover. The cards are each actuator's Coulomb friction in its best model.
    kpi:
      filters:
        and:
          - 'kind == "model"'
          - 'best == true'
      groupBy: { property: actuator }
      kpi:
        value: { property: coulomb }
  filters: 'kind == "model"'
  order: [variant, actuator, coulomb, viscous, breakaway, stribeck_velocity, weakening, capture_fraction, capture_speed, capture_dwell, ripple, backlash, gear_stiffness, inertia, kt, current_loop, torque_scale]
  groupBy: { property: rung }
  groupOrder: [M2, M3, M4, M5, M1, M0]
  columnGroups:
    Friction: [coulomb, viscous, breakaway, stribeck_velocity, weakening]
    Capture: [capture_fraction, capture_speed, capture_dwell]
    Drivetrain: [ripple, backlash, gear_stiffness, inertia]
    Driver: [kt, current_loop, torque_scale]
  display: { coulomb: value, viscous: value, weakening: value, ripple: value, backlash: value, inertia: value, kt: value }
  record:
    sections:
      - { name: Model, properties: [variant, actuator, rung, description] }
      - { name: Terms, properties: [coulomb, viscous, weakening, ripple, backlash, inertia, kt, current_loop] }
      - { name: Code, properties: [code_commit, code_hosted, code_path, readme] }

- type: table
  name: Parameters · with CI
  intro:
    text: |
      The friction terms **split into sub-columns**: value, the 95 % CI's low and high, and the basis, each its own
      column under its term, instead of the range squeezed into the cell.
  filters:
    and:
      - 'kind == "model"'
      - '!coulomb.isEmpty()'
  order: [variant, actuator, coulomb, viscous, weakening]
  groupBy: { property: rung, direction: ASC }
  display: { coulomb: stats, viscous: stats, weakening: stats }
  stats:
    coulomb: { parts: [value, low, high, basis], labels: { low: 95% CI low, high: high } }
    viscous: { parts: [value, low, high, basis], labels: { low: 95% CI low, high: high } }
    weakening: { parts: [value, low, high, basis], labels: { low: 95% CI low, high: high } }

- type: table
  name: What each rung adds
  intro:
    text: |
      **What does each term buy?** The full twin's ablation: switch one term off and replay the held-out tapes; the
      error added is how much worse the twin gets (positive = the term helps). The strip shows every run's change on
      one scale per column (dots runs, tall tick their median). The cards: the median added per rung, across actuators.
    kpi:
      filters: 'kind == "term"'
      groupBy: { property: rung }
      kpi:
        value: { property: delta_x, summary: Median }
  filters: 'kind == "term"'
  order: [term, actuator, delta_mrad, delta_x, term_note]
  groupBy: { property: rung }
  groupOrder: [M2, M3, M4, driver]
  sort:
    - { property: delta_x, direction: DESC }
  summaries: { delta_x: Median }
  display: { delta_mrad: dist }