{
  "node": {
    "id": "term:feedback-feedforward-control",
    "type": "Term",
    "label": "Feedback and feedforward control",
    "properties": {
      "id": "feedback-feedforward-control",
      "name": "Feedback and feedforward control",
      "aka": [
        "closed-loop control",
        "open-loop control",
        "feedback control",
        "feedforward control"
      ],
      "section": "topic-data",
      "definition": "Two ways of deciding a control input. Feedback measures the result and corrects an error after it appears; feedforward acts in advance on a known disturbance or setpoint, using a model. A battery cooling loop may feed forward the heat expected from the requested current and use feedback on cell temperature to trim the remaining error.",
      "related": [
        "pid-controller",
        "plant-model",
        "model-predictive-control",
        "thermal-management",
        "heat-generation"
      ],
      "url": "https://lemonergy.com/learn/glossary/feedback-feedforward-control/",
      "mentions": []
    }
  },
  "edges": [
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:battery-contact-monitor",
      "source": "term:feedback-feedforward-control",
      "target": "block:battery-contact-monitor",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:battery-current-monitor",
      "source": "term:feedback-feedforward-control",
      "target": "block:battery-current-monitor",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:battery-temperature-monitor",
      "source": "term:feedback-feedforward-control",
      "target": "block:battery-temperature-monitor",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:battery-voltage-monitor",
      "source": "term:feedback-feedforward-control",
      "target": "block:battery-voltage-monitor",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:boolean-latch",
      "source": "term:feedback-feedforward-control",
      "target": "block:boolean-latch",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:bus-select",
      "source": "term:feedback-feedforward-control",
      "target": "block:bus-select",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:chart",
      "source": "term:feedback-feedforward-control",
      "target": "block:chart",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:manual-variant-sink",
      "source": "term:feedback-feedforward-control",
      "target": "block:manual-variant-sink",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:manual-variant-source",
      "source": "term:feedback-feedforward-control",
      "target": "block:manual-variant-source",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:mpc",
      "source": "term:feedback-feedforward-control",
      "target": "block:mpc",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:native-arithmetic-shift",
      "source": "term:feedback-feedforward-control",
      "target": "block:native-arithmetic-shift",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:native-assertion",
      "source": "term:feedback-feedforward-control",
      "target": "block:native-assertion",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:native-bit-clear",
      "source": "term:feedback-feedforward-control",
      "target": "block:native-bit-clear",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:native-bit-set",
      "source": "term:feedback-feedforward-control",
      "target": "block:native-bit-set",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:native-bitwise-operator",
      "source": "term:feedback-feedforward-control",
      "target": "block:native-bitwise-operator",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:native-boolean-operator",
      "source": "term:feedback-feedforward-control",
      "target": "block:native-boolean-operator",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:native-check-dynamic-gap",
      "source": "term:feedback-feedforward-control",
      "target": "block:native-check-dynamic-gap",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:native-check-dynamic-lower",
      "source": "term:feedback-feedforward-control",
      "target": "block:native-check-dynamic-lower",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:native-check-dynamic-range",
      "source": "term:feedback-feedforward-control",
      "target": "block:native-check-dynamic-range",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:native-check-dynamic-upper",
      "source": "term:feedback-feedforward-control",
      "target": "block:native-check-dynamic-upper",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:native-check-gap",
      "source": "term:feedback-feedforward-control",
      "target": "block:native-check-gap",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:native-check-gradient",
      "source": "term:feedback-feedforward-control",
      "target": "block:native-check-gradient",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:native-check-lower",
      "source": "term:feedback-feedforward-control",
      "target": "block:native-check-lower",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:native-check-range",
      "source": "term:feedback-feedforward-control",
      "target": "block:native-check-range",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:native-check-resolution",
      "source": "term:feedback-feedforward-control",
      "target": "block:native-check-resolution",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:native-check-static-gap",
      "source": "term:feedback-feedforward-control",
      "target": "block:native-check-static-gap",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:native-check-upper",
      "source": "term:feedback-feedforward-control",
      "target": "block:native-check-upper",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:native-compare-zero",
      "source": "term:feedback-feedforward-control",
      "target": "block:native-compare-zero",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:native-discrete-pid",
      "source": "term:feedback-feedforward-control",
      "target": "block:native-discrete-pid",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:native-dynamic-interval",
      "source": "term:feedback-feedforward-control",
      "target": "block:native-dynamic-interval",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:native-extract-bits",
      "source": "term:feedback-feedforward-control",
      "target": "block:native-extract-bits",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:native-float32-bits",
      "source": "term:feedback-feedforward-control",
      "target": "block:native-float32-bits",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:native-integer-bits",
      "source": "term:feedback-feedforward-control",
      "target": "block:native-integer-bits",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:native-interval-test",
      "source": "term:feedback-feedforward-control",
      "target": "block:native-interval-test",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:native-manual-switch",
      "source": "term:feedback-feedforward-control",
      "target": "block:native-manual-switch",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:native-multiport-switch",
      "source": "term:feedback-feedforward-control",
      "target": "block:native-multiport-switch",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:native-pid",
      "source": "term:feedback-feedforward-control",
      "target": "block:native-pid",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:native-selector",
      "source": "term:feedback-feedforward-control",
      "target": "block:native-selector",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:native-stop-simulation",
      "source": "term:feedback-feedforward-control",
      "target": "block:native-stop-simulation",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:native-switch-case-actions",
      "source": "term:feedback-feedforward-control",
      "target": "block:native-switch-case-actions",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:native-truth-table",
      "source": "term:feedback-feedforward-control",
      "target": "block:native-truth-table",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:pi-controller",
      "source": "term:feedback-feedforward-control",
      "target": "block:pi-controller",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:select",
      "source": "term:feedback-feedforward-control",
      "target": "block:select",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:variant-end",
      "source": "term:feedback-feedforward-control",
      "target": "block:variant-end",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:variant-sink",
      "source": "term:feedback-feedforward-control",
      "target": "block:variant-sink",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:variant-source",
      "source": "term:feedback-feedforward-control",
      "target": "block:variant-source",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:variant-start",
      "source": "term:feedback-feedforward-control",
      "target": "block:variant-start",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:variant-subsystem",
      "source": "term:feedback-feedforward-control",
      "target": "block:variant-subsystem",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usesBlock/term:feedback-feedforward-control/block:vector-select",
      "source": "term:feedback-feedforward-control",
      "target": "block:vector-select",
      "type": "usesBlock",
      "properties": {
        "sourceFile": "studio-help-catalog.json",
        "scope": "Declared interface quantity or semantic operation; not a numerical validation claim"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-delay",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-delay",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-discrete-integrator",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-discrete-integrator",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-discrete-derivative",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-discrete-derivative",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-discrete-filter",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-discrete-filter",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-fir-filter",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-fir-filter",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-resettable-delay",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-resettable-delay",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-variable-delay",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-variable-delay",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-change",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-change",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-increase",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-increase",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-decrease",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-decrease",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-rising-edge",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-rising-edge",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-falling-edge",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-falling-edge",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-running-minmax",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-running-minmax",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-sample-hold",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-sample-hold",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-discrete-state-space",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-discrete-state-space",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-discrete-pid",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-discrete-pid",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-sampled-rate-limiter",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-sampled-rate-limiter",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-sampled-backlash",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-sampled-backlash",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-sampled-relay",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-sampled-relay",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-conditional-hold",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-conditional-hold",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-difference",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-difference",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-tapped-delay",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-tapped-delay",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-rise-positive",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-rise-positive",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-fall-nonpositive",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-fall-nonpositive",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-rise-nonnegative",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-rise-nonnegative",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-fall-negative",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-fall-negative",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-resettable-minmax",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-resettable-minmax",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-discrete-zero-pole",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-discrete-zero-pole",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-discrete-first-order",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-discrete-first-order",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-discrete-lead-lag",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-discrete-lead-lag",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-discrete-real-zero",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-discrete-real-zero",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-dynamic-rate-limiter",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-dynamic-rate-limiter",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-duty-pwm",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-duty-pwm",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-variable-pulse",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-variable-pulse",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-pid",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-pid",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-propagation-delay",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-propagation-delay",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-enabled-submodel",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-enabled-submodel",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-triggered-submodel",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-triggered-submodel",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-enabled-triggered-submodel",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-enabled-triggered-submodel",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-resettable-submodel",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-resettable-submodel",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-function-call-submodel",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-function-call-submodel",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-for-each-submodel",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-for-each-submodel",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-for-iterator-submodel",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-for-iterator-submodel",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-while-iterator-submodel",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-while-iterator-submodel",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-action-submodel",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-action-submodel",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-if-actions",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-if-actions",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-switch-case-actions",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-switch-case-actions",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-call-generator",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-call-generator",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-call-count-split",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-call-count-split",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-invocation-feedback",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-invocation-feedback",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-exclusive-merge",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-exclusive-merge",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-parameter-writer",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-parameter-writer",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-state-reader",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-state-reader",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:usedIn/term:feedback-feedforward-control/workflow:native-native-state-writer",
      "source": "term:feedback-feedforward-control",
      "target": "workflow:native-native-state-writer",
      "type": "usedIn",
      "properties": {
        "sourceFile": "wiki-blocks.json"
      }
    },
    {
      "id": "edge:belongsTo/term:feedback-feedforward-control/topic:topic-data",
      "source": "term:feedback-feedforward-control",
      "target": "topic:topic-data",
      "type": "belongsTo",
      "properties": {
        "sourceFile": "terms.json"
      }
    },
    {
      "id": "edge:relatedTo/term:feedback-feedforward-control/term:pid-controller",
      "source": "term:feedback-feedforward-control",
      "target": "term:pid-controller",
      "type": "relatedTo",
      "properties": {
        "sourceFile": "terms.json",
        "meaning": "Related context; not a causal claim"
      }
    },
    {
      "id": "edge:relatedTo/term:feedback-feedforward-control/term:plant-model",
      "source": "term:feedback-feedforward-control",
      "target": "term:plant-model",
      "type": "relatedTo",
      "properties": {
        "sourceFile": "terms.json",
        "meaning": "Related context; not a causal claim"
      }
    },
    {
      "id": "edge:relatedTo/term:feedback-feedforward-control/term:model-predictive-control",
      "source": "term:feedback-feedforward-control",
      "target": "term:model-predictive-control",
      "type": "relatedTo",
      "properties": {
        "sourceFile": "terms.json",
        "meaning": "Related context; not a causal claim"
      }
    },
    {
      "id": "edge:relatedTo/term:feedback-feedforward-control/term:thermal-management",
      "source": "term:feedback-feedforward-control",
      "target": "term:thermal-management",
      "type": "relatedTo",
      "properties": {
        "sourceFile": "terms.json",
        "meaning": "Related context; not a causal claim"
      }
    },
    {
      "id": "edge:relatedTo/term:feedback-feedforward-control/term:heat-generation",
      "source": "term:feedback-feedforward-control",
      "target": "term:heat-generation",
      "type": "relatedTo",
      "properties": {
        "sourceFile": "terms.json",
        "meaning": "Related context; not a causal claim"
      }
    }
  ],
  "neighbors": [
    {
      "id": "block:battery-contact-monitor",
      "type": "Block",
      "label": "Cell contact residual monitor",
      "properties": {
        "id": "battery-contact-monitor",
        "name": "Cell contact residual monitor",
        "kind": "studio",
        "summary": "Filters cell/group voltage residuals against their median and qualifies persistent differences. Residuals are not a unique contact-fault diagnosis.",
        "behavior": "Forms measured-minus-predicted voltage residuals, subtracts their channel median, filters the differences and qualifies consecutive threshold crossings when current is large enough.",
        "ports": [
          {
            "name": "measured",
            "direction": "input",
            "unit": "V",
            "description": "Measured cell/group voltages; 3 channels at the default configuration.",
            "shape": [
              3
            ],
            "elementType": "real",
            "quantity": "voltage"
          },
          {
            "name": "predicted",
            "direction": "input",
            "unit": "V",
            "description": "Predicted healthy voltages; 3 channels at the default configuration.",
            "shape": [
              3
            ],
            "elementType": "real",
            "quantity": "voltage"
          },
          {
            "name": "current",
            "direction": "input",
            "unit": "A",
            "description": "Signed current; scalar.",
            "shape": [],
            "elementType": "real",
            "quantity": "current"
          },
          {
            "name": "enable",
            "direction": "input",
            "unit": "true / false",
            "description": "Enable; scalar.",
            "shape": [],
            "elementType": "bool",
            "quantity": "dimensionless"
          },
          {
            "name": "residual",
            "direction": "output",
            "unit": "V",
            "description": "Filtered differential residual; 3 channels at the default configuration.",
            "shape": [
              3
            ],
            "elementType": "real",
            "quantity": "voltage"
          },
          {
            "name": "faults",
            "direction": "output",
            "unit": "true / false",
            "description": "Qualified channel symptoms; 3 channels at the default configuration.",
            "shape": [
              3
            ],
            "elementType": "bool",
            "quantity": "dimensionless"
          },
          {
            "name": "fault",
            "direction": "output",
            "unit": "true / false",
            "description": "Any qualified symptom; scalar.",
            "shape": [],
            "elementType": "bool",
            "quantity": "dimensionless"
          },
          {
            "name": "valid",
            "direction": "output",
            "unit": "true / false",
            "description": "Sufficient current; scalar.",
            "shape": [],
            "elementType": "bool",
            "quantity": "dimensionless"
          }
        ],
        "parameters": [
          {
            "key": "sampleTimeS",
            "label": "Sample interval (s)",
            "unit": "s",
            "default": 1,
            "description": "Positive sample interval. Initialization has zero elapsed time; subsequent accepted samples update memory."
          },
          {
            "key": "cells",
            "label": "Number of measurement channels",
            "unit": "1",
            "default": 3,
            "description": "Number of measurement channels. This is an editable model input; the default belongs to the synthetic worked example."
          },
          {
            "key": "filterWeight",
            "label": "Residual filter weight (0–1)",
            "unit": "0–1",
            "default": 0.5,
            "description": "Residual filter weight (0–1). This is an editable model input; the default belongs to the synthetic worked example."
          },
          {
            "key": "thresholdV",
            "label": "Residual threshold (V)",
            "unit": "V",
            "default": 0.008,
            "description": "Residual threshold (V). This is an editable model input; the default belongs to the synthetic worked example."
          },
          {
            "key": "minCurrentA",
            "label": "Minimum diagnostic current (A)",
            "unit": "A",
            "default": 1,
            "description": "Minimum diagnostic current (A). This is an editable model input; the default belongs to the synthetic worked example."
          },
          {
            "key": "requiredSamples",
            "label": "Consecutive qualifying samples",
            "unit": "1",
            "default": 2,
            "description": "Consecutive qualifying samples. This is an editable model input; the default belongs to the synthetic worked example."
          }
        ],
        "equations": [
          "d[j] = measured[j] - predicted[j]",
          "residual[j] = filtered(d[j] - median(d))"
        ],
        "example": {
          "title": "Cell contact residual monitor worked example",
          "text": "Use the defaults below with Measured cell/group voltages = [3.64, 3.66, 3.66] V, Predicted healthy voltages = [3.66, 3.66, 3.66] V, Signed current = 2 A, Enable = 1 true / false. At 0 s, Filtered differential residual is [0, 0, 0] V. Additional checks are listed below.",
          "url": "https://design.lemonergy.com/cosim.html?example=block-battery-contact-monitor",
          "label": "Open Studio example",
          "checks": [
            {
              "port": "residual",
              "atS": 0,
              "value": [
                0,
                0,
                0
              ],
              "tolerance": 1e-08,
              "label": "Filtered differential residual",
              "unit": "V"
            },
            {
              "port": "fault",
              "atS": 0,
              "value": 0,
              "tolerance": 1e-08,
              "label": "Any qualified symptom",
              "unit": "true / false"
            },
            {
              "port": "valid",
              "atS": 0,
              "value": 1,
              "tolerance": 1e-08,
              "label": "Sufficient current",
              "unit": "true / false"
            },
            {
              "port": "fault",
              "atS": 2,
              "value": 1,
              "tolerance": 0,
              "label": "Any qualified symptom",
              "unit": "true / false"
            }
          ],
          "inputs": [
            {
              "port": "measured",
              "label": "Measured cell/group voltages",
              "value": [
                3.64,
                3.66,
                3.66
              ],
              "unit": "V"
            },
            {
              "port": "predicted",
              "label": "Predicted healthy voltages",
              "value": [
                3.66,
                3.66,
                3.66
              ],
              "unit": "V"
            },
            {
              "port": "current",
              "label": "Signed current",
              "value": 2,
              "unit": "A"
            },
            {
              "port": "enable",
              "label": "Enable",
              "value": 1,
              "unit": "true / false"
            }
          ]
        },
        "limits": [
          "Requires at least three channels. Contact loss, parameter mismatch and sensor bias can produce the same symptom; this is not a unique fault diagnosis.",
          "The example verifies numerical behavior for synthetic parameters. Cell characterization and validation for an intended use are separate tasks."
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "references": [
          "ti-bms"
        ],
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "caseIds": [
          "native-battery-contact-monitor"
        ],
        "exampleTraces": [
          {
            "id": "battery-contact-monitor",
            "url": "https://lemonergy.com/learn/glossary/api/traces/battery-contact-monitor.json?v=5297694cf49e",
            "title": "Cell contact residual monitor recorded example",
            "exampleId": "block-battery-contact-monitor",
            "source": "Executed synthetic Lemonergy Studio example",
            "recordedOn": "2026-10-28",
            "points": 4,
            "channels": 8,
            "omittedChannels": 0,
            "interpolation": "step",
            "solver": {
              "method": "dormand-prince-45",
              "reason": "no-continuous-states"
            }
          }
        ],
        "type": "battery-contact-monitor",
        "implementationId": "battery-contact-monitor",
        "url": "https://lemonergy.com/learn/glossary/blocks/battery-contact-monitor/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/battery-contact-monitor/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=block-battery-contact-monitor"
          ]
        },
        "studioHelp": {
          "type": "battery-contact-monitor",
          "namespace": "signal",
          "slug": "signal-block-battery-contact-monitor",
          "canonicalSlug": "battery-contact-monitor",
          "existing": true,
          "dynamic": false,
          "scene": {
            "title": "Cell contact residual monitor",
            "label": "Cell contact residual monitor",
            "summary": "Filters cell/group voltage residuals against their median and qualifies persistent differences. Residuals are not a unique contact-fault diagnosis.",
            "details": [
              "Block type: battery-contact-monitor.",
              "4 declared inputs and 4 declared outputs in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "signal → bounds → fault",
              "label": "Compare monitored channels",
              "caption": "Filters cell/group voltage residuals against their median and qualifies persistent differences. Residuals are not a unique contact-fault diagnosis."
            },
            "inputs": [
              {
                "id": "measured",
                "label": "Measured cell/group voltages",
                "quantity": "voltage",
                "shape": [
                  3
                ],
                "elementType": "real",
                "unit": "V",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Voltage",
                "shapeLabel": "Array 3",
                "elementLabel": "real"
              },
              {
                "id": "predicted",
                "label": "Predicted healthy voltages",
                "quantity": "voltage",
                "shape": [
                  3
                ],
                "elementType": "real",
                "unit": "V",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Voltage",
                "shapeLabel": "Array 3",
                "elementLabel": "real"
              },
              {
                "id": "current",
                "label": "Signed current",
                "quantity": "current",
                "shape": [],
                "elementType": "real",
                "unit": "A",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Current",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              },
              {
                "id": "enable",
                "label": "Enable",
                "quantity": "dimensionless",
                "shape": [],
                "elementType": "bool",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "bool"
              }
            ],
            "outputs": [
              {
                "id": "residual",
                "label": "Filtered differential residual",
                "quantity": "voltage",
                "shape": [
                  3
                ],
                "elementType": "real",
                "unit": "V",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Voltage",
                "shapeLabel": "Array 3",
                "elementLabel": "real"
              },
              {
                "id": "faults",
                "label": "Qualified channel symptoms",
                "quantity": "dimensionless",
                "shape": [
                  3
                ],
                "elementType": "bool",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Array 3",
                "elementLabel": "bool"
              },
              {
                "id": "fault",
                "label": "Any qualified symptom",
                "quantity": "dimensionless",
                "shape": [],
                "elementType": "bool",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "bool"
              },
              {
                "id": "valid",
                "label": "Sufficient current",
                "quantity": "dimensionless",
                "shape": [],
                "elementType": "bool",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "bool"
              }
            ],
            "parameters": [
              {
                "id": "configuration",
                "label": "Configuration",
                "unit": "",
                "value": "{\"sampleTimeS\":1,\"cells\":3,\"filterWeight\":0.5,\"thresholdV\":0.008,\"minCurrentA\":1,\"requiredSamples\":2}"
              }
            ],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-battery-contact-monitor/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:battery-current-monitor",
      "type": "Block",
      "label": "Battery current monitor",
      "properties": {
        "id": "battery-current-monitor",
        "name": "Battery current monitor",
        "kind": "studio",
        "summary": "Reports each channel below/above its bounds and a combined fault.",
        "behavior": "Compares each measured channel with strict lower and upper bounds. A value equal to a bound does not trip. The combined output is true when any channel is outside the bounds.",
        "ports": [
          {
            "name": "values",
            "direction": "input",
            "unit": "A",
            "description": "Channel measurements; 3 channels at the default configuration.",
            "shape": [
              3
            ],
            "elementType": "real",
            "quantity": "current"
          },
          {
            "name": "low",
            "direction": "output",
            "unit": "true / false",
            "description": "Below lower bound; 3 channels at the default configuration.",
            "shape": [
              3
            ],
            "elementType": "bool",
            "quantity": "dimensionless"
          },
          {
            "name": "high",
            "direction": "output",
            "unit": "true / false",
            "description": "Above upper bound; 3 channels at the default configuration.",
            "shape": [
              3
            ],
            "elementType": "bool",
            "quantity": "dimensionless"
          },
          {
            "name": "fault",
            "direction": "output",
            "unit": "true / false",
            "description": "Any fault; scalar.",
            "shape": [],
            "elementType": "bool",
            "quantity": "dimensionless"
          }
        ],
        "parameters": [
          {
            "key": "cells",
            "label": "Number of measurement channels",
            "unit": "1",
            "default": 3,
            "description": "Number of measurement channels. This is an editable model input; the default belongs to the synthetic worked example."
          },
          {
            "key": "lower",
            "label": "Lower threshold (A)",
            "unit": "A",
            "default": -2,
            "description": "Lower threshold (A). This is an editable model input; the default belongs to the synthetic worked example."
          },
          {
            "key": "upper",
            "label": "Upper threshold (A)",
            "unit": "A",
            "default": 3,
            "description": "Upper threshold (A). This is an editable model input; the default belongs to the synthetic worked example."
          }
        ],
        "equations": [
          "low[j] = value[j] < lower",
          "high[j] = value[j] > upper",
          "fault = any(low) or any(high)"
        ],
        "example": {
          "title": "Battery current monitor worked example",
          "text": "Use the defaults below with Channel measurements = [-2, 0, 3.1] A. At 0 s, Any fault is 1 true / false. Additional checks are listed below.",
          "url": "https://design.lemonergy.com/cosim.html?example=block-battery-current-monitor",
          "label": "Open Studio example",
          "checks": [
            {
              "port": "fault",
              "atS": 0,
              "value": 1,
              "tolerance": 1e-08,
              "label": "Any fault",
              "unit": "true / false"
            }
          ],
          "inputs": [
            {
              "port": "values",
              "label": "Channel measurements",
              "value": [
                -2,
                0,
                3.1
              ],
              "unit": "A"
            }
          ]
        },
        "limits": [
          "Bounds are user-supplied. This comparator does not disconnect a circuit or diagnose a sensor failure.",
          "The example verifies numerical behavior for synthetic parameters. Cell characterization and validation for an intended use are separate tasks."
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "references": [
          "ti-bms"
        ],
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "caseIds": [
          "native-battery-current-monitor"
        ],
        "exampleTraces": [
          {
            "id": "battery-current-monitor",
            "url": "https://lemonergy.com/learn/glossary/api/traces/battery-current-monitor.json?v=9616a055815e",
            "title": "Battery current monitor recorded example",
            "exampleId": "block-battery-current-monitor",
            "source": "Executed synthetic Lemonergy Studio example",
            "recordedOn": "2026-10-28",
            "points": 2,
            "channels": 7,
            "omittedChannels": 0,
            "interpolation": "linear",
            "solver": {
              "method": "dormand-prince-45",
              "reason": "no-continuous-states"
            }
          }
        ],
        "type": "battery-current-monitor",
        "implementationId": "battery-current-monitor",
        "url": "https://lemonergy.com/learn/glossary/blocks/battery-current-monitor/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/battery-current-monitor/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=block-battery-current-monitor"
          ]
        },
        "studioHelp": {
          "type": "battery-current-monitor",
          "namespace": "signal",
          "slug": "signal-block-battery-current-monitor",
          "canonicalSlug": "battery-current-monitor",
          "existing": true,
          "dynamic": false,
          "scene": {
            "title": "Battery current monitor",
            "label": "Battery current monitor",
            "summary": "Reports each channel below/above its bounds and a combined fault.",
            "details": [
              "Block type: battery-current-monitor.",
              "1 declared input and 3 declared outputs in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "signal → bounds → fault",
              "label": "Compare monitored channels",
              "caption": "Reports each channel below/above its bounds and a combined fault."
            },
            "inputs": [
              {
                "id": "values",
                "label": "Channel measurements",
                "quantity": "current",
                "shape": [
                  3
                ],
                "elementType": "real",
                "unit": "A",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Current",
                "shapeLabel": "Array 3",
                "elementLabel": "real"
              }
            ],
            "outputs": [
              {
                "id": "low",
                "label": "Below lower bound",
                "quantity": "dimensionless",
                "shape": [
                  3
                ],
                "elementType": "bool",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Array 3",
                "elementLabel": "bool"
              },
              {
                "id": "high",
                "label": "Above upper bound",
                "quantity": "dimensionless",
                "shape": [
                  3
                ],
                "elementType": "bool",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Array 3",
                "elementLabel": "bool"
              },
              {
                "id": "fault",
                "label": "Any fault",
                "quantity": "dimensionless",
                "shape": [],
                "elementType": "bool",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "bool"
              }
            ],
            "parameters": [
              {
                "id": "configuration",
                "label": "Configuration",
                "unit": "",
                "value": "{\"cells\":3,\"lower\":-2,\"upper\":3}"
              }
            ],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-battery-current-monitor/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:battery-temperature-monitor",
      "type": "Block",
      "label": "Battery temperature monitor",
      "properties": {
        "id": "battery-temperature-monitor",
        "name": "Battery temperature monitor",
        "kind": "studio",
        "summary": "Reports each channel below/above its bounds and a combined fault.",
        "behavior": "Compares each measured channel with strict lower and upper bounds. A value equal to a bound does not trip. The combined output is true when any channel is outside the bounds.",
        "ports": [
          {
            "name": "values",
            "direction": "input",
            "unit": "K",
            "description": "Channel measurements; 3 channels at the default configuration.",
            "shape": [
              3
            ],
            "elementType": "real",
            "quantity": "temperature"
          },
          {
            "name": "low",
            "direction": "output",
            "unit": "true / false",
            "description": "Below lower bound; 3 channels at the default configuration.",
            "shape": [
              3
            ],
            "elementType": "bool",
            "quantity": "dimensionless"
          },
          {
            "name": "high",
            "direction": "output",
            "unit": "true / false",
            "description": "Above upper bound; 3 channels at the default configuration.",
            "shape": [
              3
            ],
            "elementType": "bool",
            "quantity": "dimensionless"
          },
          {
            "name": "fault",
            "direction": "output",
            "unit": "true / false",
            "description": "Any fault; scalar.",
            "shape": [],
            "elementType": "bool",
            "quantity": "dimensionless"
          }
        ],
        "parameters": [
          {
            "key": "cells",
            "label": "Number of measurement channels",
            "unit": "1",
            "default": 3,
            "description": "Number of measurement channels. This is an editable model input; the default belongs to the synthetic worked example."
          },
          {
            "key": "lower",
            "label": "Lower threshold (K)",
            "unit": "K",
            "default": 273.15,
            "description": "Lower threshold (K). This is an editable model input; the default belongs to the synthetic worked example."
          },
          {
            "key": "upper",
            "label": "Upper threshold (K)",
            "unit": "K",
            "default": 318.15,
            "description": "Upper threshold (K). This is an editable model input; the default belongs to the synthetic worked example."
          }
        ],
        "equations": [
          "low[j] = value[j] < lower",
          "high[j] = value[j] > upper",
          "fault = any(low) or any(high)"
        ],
        "example": {
          "title": "Battery temperature monitor worked example",
          "text": "Use the defaults below with Channel measurements = [272, 298.15, 318.15] K. At 0 s, Any fault is 1 true / false. Additional checks are listed below.",
          "url": "https://design.lemonergy.com/cosim.html?example=block-battery-temperature-monitor",
          "label": "Open Studio example",
          "checks": [
            {
              "port": "fault",
              "atS": 0,
              "value": 1,
              "tolerance": 1e-08,
              "label": "Any fault",
              "unit": "true / false"
            }
          ],
          "inputs": [
            {
              "port": "values",
              "label": "Channel measurements",
              "value": [
                272,
                298.15,
                318.15
              ],
              "unit": "K"
            }
          ]
        },
        "limits": [
          "Bounds are user-supplied. This comparator does not disconnect a circuit or diagnose a sensor failure.",
          "The example verifies numerical behavior for synthetic parameters. Cell characterization and validation for an intended use are separate tasks."
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "references": [
          "ti-bms"
        ],
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "caseIds": [
          "native-battery-temperature-monitor"
        ],
        "exampleTraces": [
          {
            "id": "battery-temperature-monitor",
            "url": "https://lemonergy.com/learn/glossary/api/traces/battery-temperature-monitor.json?v=c457b18223f2",
            "title": "Battery temperature monitor recorded example",
            "exampleId": "block-battery-temperature-monitor",
            "source": "Executed synthetic Lemonergy Studio example",
            "recordedOn": "2026-10-28",
            "points": 2,
            "channels": 7,
            "omittedChannels": 0,
            "interpolation": "linear",
            "solver": {
              "method": "dormand-prince-45",
              "reason": "no-continuous-states"
            }
          }
        ],
        "type": "battery-temperature-monitor",
        "implementationId": "battery-temperature-monitor",
        "url": "https://lemonergy.com/learn/glossary/blocks/battery-temperature-monitor/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/battery-temperature-monitor/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=block-battery-temperature-monitor"
          ]
        },
        "studioHelp": {
          "type": "battery-temperature-monitor",
          "namespace": "signal",
          "slug": "signal-block-battery-temperature-monitor",
          "canonicalSlug": "battery-temperature-monitor",
          "existing": true,
          "dynamic": false,
          "scene": {
            "title": "Battery temperature monitor",
            "label": "Battery temperature monitor",
            "summary": "Reports each channel below/above its bounds and a combined fault.",
            "details": [
              "Block type: battery-temperature-monitor.",
              "1 declared input and 3 declared outputs in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "signal → bounds → fault",
              "label": "Compare monitored channels",
              "caption": "Reports each channel below/above its bounds and a combined fault."
            },
            "inputs": [
              {
                "id": "values",
                "label": "Channel measurements",
                "quantity": "temperature",
                "shape": [
                  3
                ],
                "elementType": "real",
                "unit": "K",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Temperature",
                "shapeLabel": "Array 3",
                "elementLabel": "real"
              }
            ],
            "outputs": [
              {
                "id": "low",
                "label": "Below lower bound",
                "quantity": "dimensionless",
                "shape": [
                  3
                ],
                "elementType": "bool",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Array 3",
                "elementLabel": "bool"
              },
              {
                "id": "high",
                "label": "Above upper bound",
                "quantity": "dimensionless",
                "shape": [
                  3
                ],
                "elementType": "bool",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Array 3",
                "elementLabel": "bool"
              },
              {
                "id": "fault",
                "label": "Any fault",
                "quantity": "dimensionless",
                "shape": [],
                "elementType": "bool",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "bool"
              }
            ],
            "parameters": [
              {
                "id": "configuration",
                "label": "Configuration",
                "unit": "",
                "value": "{\"cells\":3,\"lower\":273.15,\"upper\":318.15}"
              }
            ],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-battery-temperature-monitor/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:battery-voltage-monitor",
      "type": "Block",
      "label": "Battery voltage monitor",
      "properties": {
        "id": "battery-voltage-monitor",
        "name": "Battery voltage monitor",
        "kind": "studio",
        "summary": "Reports each channel below/above its bounds and a combined fault.",
        "behavior": "Compares each measured channel with strict lower and upper bounds. A value equal to a bound does not trip. The combined output is true when any channel is outside the bounds.",
        "ports": [
          {
            "name": "values",
            "direction": "input",
            "unit": "V",
            "description": "Channel measurements; 3 channels at the default configuration.",
            "shape": [
              3
            ],
            "elementType": "real",
            "quantity": "voltage"
          },
          {
            "name": "low",
            "direction": "output",
            "unit": "true / false",
            "description": "Below lower bound; 3 channels at the default configuration.",
            "shape": [
              3
            ],
            "elementType": "bool",
            "quantity": "dimensionless"
          },
          {
            "name": "high",
            "direction": "output",
            "unit": "true / false",
            "description": "Above upper bound; 3 channels at the default configuration.",
            "shape": [
              3
            ],
            "elementType": "bool",
            "quantity": "dimensionless"
          },
          {
            "name": "fault",
            "direction": "output",
            "unit": "true / false",
            "description": "Any fault; scalar.",
            "shape": [],
            "elementType": "bool",
            "quantity": "dimensionless"
          }
        ],
        "parameters": [
          {
            "key": "cells",
            "label": "Number of measurement channels",
            "unit": "1",
            "default": 3,
            "description": "Number of measurement channels. This is an editable model input; the default belongs to the synthetic worked example."
          },
          {
            "key": "lower",
            "label": "Lower threshold (V)",
            "unit": "V",
            "default": 3,
            "description": "Lower threshold (V). This is an editable model input; the default belongs to the synthetic worked example."
          },
          {
            "key": "upper",
            "label": "Upper threshold (V)",
            "unit": "V",
            "default": 4.2,
            "description": "Upper threshold (V). This is an editable model input; the default belongs to the synthetic worked example."
          }
        ],
        "equations": [
          "low[j] = value[j] < lower",
          "high[j] = value[j] > upper",
          "fault = any(low) or any(high)"
        ],
        "example": {
          "title": "Battery voltage monitor worked example",
          "text": "Use the defaults below with Channel measurements = [3, 4, 4.3] V. At 0 s, Any fault is 1 true / false. Additional checks are listed below.",
          "url": "https://design.lemonergy.com/cosim.html?example=block-battery-voltage-monitor",
          "label": "Open Studio example",
          "checks": [
            {
              "port": "fault",
              "atS": 0,
              "value": 1,
              "tolerance": 1e-08,
              "label": "Any fault",
              "unit": "true / false"
            }
          ],
          "inputs": [
            {
              "port": "values",
              "label": "Channel measurements",
              "value": [
                3,
                4,
                4.3
              ],
              "unit": "V"
            }
          ]
        },
        "limits": [
          "Bounds are user-supplied. This comparator does not disconnect a circuit or diagnose a sensor failure.",
          "The example verifies numerical behavior for synthetic parameters. Cell characterization and validation for an intended use are separate tasks."
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "references": [
          "ti-bms"
        ],
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "caseIds": [
          "native-battery-voltage-monitor"
        ],
        "exampleTraces": [
          {
            "id": "battery-voltage-monitor",
            "url": "https://lemonergy.com/learn/glossary/api/traces/battery-voltage-monitor.json?v=5694383c3d4d",
            "title": "Battery voltage monitor recorded example",
            "exampleId": "block-battery-voltage-monitor",
            "source": "Executed synthetic Lemonergy Studio example",
            "recordedOn": "2026-10-28",
            "points": 2,
            "channels": 7,
            "omittedChannels": 0,
            "interpolation": "linear",
            "solver": {
              "method": "dormand-prince-45",
              "reason": "no-continuous-states"
            }
          }
        ],
        "type": "battery-voltage-monitor",
        "implementationId": "battery-voltage-monitor",
        "url": "https://lemonergy.com/learn/glossary/blocks/battery-voltage-monitor/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/battery-voltage-monitor/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=block-battery-voltage-monitor"
          ]
        },
        "studioHelp": {
          "type": "battery-voltage-monitor",
          "namespace": "signal",
          "slug": "signal-block-battery-voltage-monitor",
          "canonicalSlug": "battery-voltage-monitor",
          "existing": true,
          "dynamic": false,
          "scene": {
            "title": "Battery voltage monitor",
            "label": "Battery voltage monitor",
            "summary": "Reports each channel below/above its bounds and a combined fault.",
            "details": [
              "Block type: battery-voltage-monitor.",
              "1 declared input and 3 declared outputs in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "signal → bounds → fault",
              "label": "Compare monitored channels",
              "caption": "Reports each channel below/above its bounds and a combined fault."
            },
            "inputs": [
              {
                "id": "values",
                "label": "Channel measurements",
                "quantity": "voltage",
                "shape": [
                  3
                ],
                "elementType": "real",
                "unit": "V",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Voltage",
                "shapeLabel": "Array 3",
                "elementLabel": "real"
              }
            ],
            "outputs": [
              {
                "id": "low",
                "label": "Below lower bound",
                "quantity": "dimensionless",
                "shape": [
                  3
                ],
                "elementType": "bool",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Array 3",
                "elementLabel": "bool"
              },
              {
                "id": "high",
                "label": "Above upper bound",
                "quantity": "dimensionless",
                "shape": [
                  3
                ],
                "elementType": "bool",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Array 3",
                "elementLabel": "bool"
              },
              {
                "id": "fault",
                "label": "Any fault",
                "quantity": "dimensionless",
                "shape": [],
                "elementType": "bool",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "bool"
              }
            ],
            "parameters": [
              {
                "id": "configuration",
                "label": "Configuration",
                "unit": "",
                "value": "{\"cells\":3,\"lower\":3,\"upper\":4.2}"
              }
            ],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-battery-voltage-monitor/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:boolean-latch",
      "type": "Block",
      "label": "Boolean latch",
      "properties": {
        "id": "boolean-latch",
        "kind": "studio",
        "name": "Boolean latch",
        "summary": "Sampled set/reset memory. SET wins when both inputs are 1; holds when both are 0. Inputs must be exactly 0 or 1.",
        "behavior": "Sampled set/reset memory. SET wins when both inputs are 1; holds when both are 0. Inputs must be exactly 0 or 1.",
        "documentationSlug": "signal-block-boolean-latch",
        "referenceOnly": true,
        "ports": [
          {
            "name": "Set (0 or 1)",
            "direction": "input",
            "unit": "—",
            "description": "Number; Scalar; real. Received from a connected producer."
          },
          {
            "name": "Reset (0 or 1)",
            "direction": "input",
            "unit": "—",
            "description": "Number; Scalar; real. Received from a connected producer."
          },
          {
            "name": "Output",
            "direction": "output",
            "unit": "—",
            "description": "Number; Scalar; real. Produced for connected consumers."
          }
        ],
        "parameters": [
          {
            "key": "sampleTimeS",
            "label": "Sample time",
            "unit": "s",
            "default": "0.01",
            "description": "Declared authoring field: Sample time."
          },
          {
            "key": "initial",
            "label": "Initial output (0 or 1)",
            "unit": "",
            "default": "0",
            "description": "Declared authoring field: Initial output (0 or 1)."
          }
        ],
        "equations": [],
        "example": {
          "title": "Use this authoring component",
          "text": "Choose this component in the Studio library and configure its declared interface. This reference describes the authoring contract; it does not claim a standalone numerical validation or a measured result.",
          "url": "https://design.lemonergy.com/cosim",
          "label": "Open Studio"
        },
        "limits": [
          "The symbolic diagram describes the component and its declared interface. It is not a solved circuit or simulated output.",
          "Configured parameters and model connections determine the result. Check the complete model before interpreting its outputs."
        ],
        "evidence": [
          "docs/glossary/studio-help-catalog.json"
        ],
        "caseIds": [],
        "sourceRepository": "battery-design",
        "sourceRevision": "0a28f1a0a75a0447903b868cbcc734133a77a847",
        "reviewed": "2026-10-30",
        "type": "boolean-latch",
        "implementationId": "boolean-latch",
        "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/",
        "sourceFile": "studio-help-catalog.json",
        "studioHelp": {
          "type": "boolean-latch",
          "namespace": "signal",
          "slug": "signal-block-boolean-latch",
          "canonicalSlug": "signal-block-boolean-latch",
          "existing": false,
          "dynamic": false,
          "scene": {
            "title": "Boolean latch",
            "label": "Boolean latch",
            "summary": "Sampled set/reset memory. SET wins when both inputs are 1; holds when both are 0. Inputs must be exactly 0 or 1.",
            "details": [
              "Block type: boolean-latch.",
              "2 declared inputs and 1 declared output in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "condition → branch",
              "label": "Selection and control",
              "caption": "Sampled set/reset memory. SET wins when both inputs are 1; holds when both are 0. Inputs must be exactly 0 or 1."
            },
            "inputs": [
              {
                "id": "in0",
                "label": "Set (0 or 1)",
                "quantity": "dimensionless",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              },
              {
                "id": "in1",
                "label": "Reset (0 or 1)",
                "quantity": "dimensionless",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              }
            ],
            "outputs": [
              {
                "id": "out0",
                "label": "Output",
                "quantity": "dimensionless",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              }
            ],
            "parameters": [
              {
                "id": "sampleTimeS",
                "label": "Sample time",
                "unit": "s",
                "value": "0.01"
              },
              {
                "id": "initial",
                "label": "Initial output (0 or 1)",
                "unit": "",
                "value": "0"
              }
            ],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:bus-select",
      "type": "Block",
      "label": "Bus selector",
      "properties": {
        "id": "bus-select",
        "name": "Bus selector",
        "kind": "studio",
        "summary": "Selects one declared field or nested field from a named bus.",
        "behavior": "A dotted field path selects the original typed value; missing fields are rejected before simulation.",
        "ports": [
          {
            "name": "bus",
            "direction": "input",
            "unit": "1",
            "description": "pack; named bus with declared typed fields."
          },
          {
            "name": "soc",
            "direction": "output",
            "unit": "fraction",
            "description": "soc; real signal.",
            "shape": [],
            "elementType": "real"
          }
        ],
        "parameters": [
          {
            "key": "bus",
            "label": "Bus declaration",
            "unit": "1",
            "default": "pack",
            "description": "Explicit bus used by this worked model."
          },
          {
            "key": "field",
            "label": "Selected field path",
            "unit": "1",
            "default": "state.soc",
            "description": "Explicit field used by this worked model."
          }
        ],
        "equations": [
          "y = bus[configured field path]"
        ],
        "example": {
          "title": "Update nested battery telemetry",
          "text": "Initial-SOC = 0.5; Updated-SOC = 0.6; Cell-voltage = 3.7. Before at 1 s = 0.5; After at 1 s = 0.6.",
          "url": "https://design.lemonergy.com/cosim.html?example=routing-nested-bus",
          "label": "Open Studio example",
          "inputs": [
            {
              "port": "Initial-SOC",
              "label": "Initial-SOC",
              "value": 0.5,
              "unit": "fraction"
            },
            {
              "port": "Updated-SOC",
              "label": "Updated-SOC",
              "value": 0.6,
              "unit": "fraction"
            },
            {
              "port": "Cell-voltage",
              "label": "Cell-voltage",
              "value": 3.7,
              "unit": "voltage"
            }
          ],
          "checks": [
            {
              "port": "Before",
              "label": "Before",
              "atS": 1,
              "value": 0.5,
              "unit": "fraction",
              "tolerance": 1e-09
            },
            {
              "port": "After",
              "label": "After",
              "atS": 1,
              "value": 0.6,
              "unit": "fraction",
              "tolerance": 1e-09
            }
          ]
        },
        "limits": [
          "Paths must exist in the declared bus version; dynamic field names are not supported."
        ],
        "references": [],
        "referenceNote": "This software operation is defined by its public contract and worked example; no external research result is claimed.",
        "caseIds": [
          "native-bus-select"
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "type": "bus-select",
        "implementationId": "bus-select",
        "url": "https://lemonergy.com/learn/glossary/blocks/bus-select/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/bus-select/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=routing-nested-bus"
          ]
        },
        "studioHelp": {
          "type": "bus-select",
          "namespace": "signal",
          "slug": "signal-block-bus-select",
          "canonicalSlug": "bus-select",
          "existing": true,
          "dynamic": true,
          "scene": {
            "title": "Bus selector",
            "label": "Bus selector",
            "summary": "Select a named field, including nested bus fields.",
            "details": [
              "Block type: bus-select.",
              "0 declared inputs and 0 declared outputs in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "condition → branch",
              "label": "Selection and control",
              "caption": "Select a named field, including nested bus fields."
            },
            "inputs": [],
            "outputs": [],
            "parameters": [],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-bus-select/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:chart",
      "type": "Block",
      "label": "Chart",
      "properties": {
        "id": "chart",
        "kind": "studio",
        "name": "Chart",
        "summary": "Sampled parallel regions, ordered guards and named held outputs.",
        "behavior": "Sampled parallel regions, ordered guards and named held outputs.",
        "documentationSlug": "signal-block-chart",
        "referenceOnly": true,
        "ports": [
          {
            "name": "command",
            "direction": "input",
            "unit": "—",
            "description": "Number; Scalar; real. Received from a connected producer."
          },
          {
            "name": "mode",
            "direction": "output",
            "unit": "—",
            "description": "Number; Scalar; real. Produced for connected consumers."
          }
        ],
        "parameters": [
          {
            "key": "chart",
            "label": "Chart document",
            "unit": "",
            "default": "{\"format\":\"lemonergy/chart@1\",\"sampleTimeS\":0.02,\"inputs\":[{\"id\":\"command\",\"quantity\":\"dimensionless\"}],\"outputs\":[{\"id\":\"mode\",\"quantity\":\"dimensionless\",\"initial\":0}],\"regions\":[{\"id\":\"supervisor\",\"initial\":\"idle\",\"states\":[{\"id\":\"idle\",\"entry\":[{\"set\":\"mode\",\"to\":0}],\"exit\":[]},{\"id\":\"active\",\"entry\":[{\"set\":\"mode\",\"to\":1}],\"exit\":[]}],\"transitions\":[{\"from\":\"idle\",\"to\":\"active\",\"when\":{\"signal\":\"command\",\"op\":\">=\",\"value\":0.5}},{\"from\":\"active\",\"to\":\"idle\",\"when\":{\"signal\":\"command\",\"op\":\"<\",\"value\":0.5}}]}]}",
            "description": "Declared authoring field: Chart document."
          }
        ],
        "equations": [],
        "example": {
          "title": "Use this authoring component",
          "text": "Choose this component in the Studio library and configure its declared interface. This reference describes the authoring contract; it does not claim a standalone numerical validation or a measured result.",
          "url": "https://design.lemonergy.com/cosim",
          "label": "Open Studio"
        },
        "limits": [
          "The symbolic diagram describes the component and its declared interface. It is not a solved circuit or simulated output.",
          "Configured parameters and model connections determine the result. Check the complete model before interpreting its outputs."
        ],
        "evidence": [
          "docs/glossary/studio-help-catalog.json"
        ],
        "caseIds": [],
        "sourceRepository": "battery-design",
        "sourceRevision": "0a28f1a0a75a0447903b868cbcc734133a77a847",
        "reviewed": "2026-10-30",
        "type": "chart",
        "implementationId": "chart",
        "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-chart/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/signal-block-chart/",
        "sourceFile": "studio-help-catalog.json",
        "studioHelp": {
          "type": "chart",
          "namespace": "signal",
          "slug": "signal-block-chart",
          "canonicalSlug": "signal-block-chart",
          "existing": false,
          "dynamic": false,
          "scene": {
            "title": "Chart",
            "label": "Chart",
            "summary": "Sampled parallel regions, ordered guards and named held outputs.",
            "details": [
              "Block type: chart.",
              "1 declared input and 1 declared output in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "guard → state",
              "label": "Ordered state transitions",
              "caption": "Sampled parallel regions, ordered guards and named held outputs."
            },
            "inputs": [
              {
                "id": "command",
                "quantity": "dimensionless",
                "label": "command",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              }
            ],
            "outputs": [
              {
                "id": "mode",
                "quantity": "dimensionless",
                "initial": 0,
                "label": "mode",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              }
            ],
            "parameters": [
              {
                "id": "chart",
                "label": "Chart document",
                "unit": "",
                "value": "{\"format\":\"lemonergy/chart@1\",\"sampleTimeS\":0.02,\"inputs\":[{\"id\":\"command\",\"quantity\":\"dimensionless\"}],\"outputs\":[{\"id\":\"mode\",\"quantity\":\"dimensionless\",\"initial\":0}],\"regions\":[{\"id\":\"supervisor\",\"initial\":\"idle\",\"states\":[{\"id\":\"idle\",\"entry\":[{\"set\":\"mode\",\"to\":0}],\"exit\":[]},{\"id\":\"active\",\"entry\":[{\"set\":\"mode\",\"to\":1}],\"exit\":[]}],\"transitions\":[{\"from\":\"idle\",\"to\":\"active\",\"when\":{\"signal\":\"command\",\"op\":\">=\",\"value\":0.5}},{\"from\":\"active\",\"to\":\"idle\",\"when\":{\"signal\":\"command\",\"op\":\"<\",\"value\":0.5}}]}]}"
              }
            ],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-chart/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:manual-variant-sink",
      "type": "Block",
      "label": "Manual variant sink",
      "properties": {
        "id": "manual-variant-sink",
        "name": "Manual variant sink",
        "kind": "studio",
        "summary": "A manually configured compile-time output branch selection.",
        "behavior": "A manual pre-run selection keeps one output path and removes inactive downstream paths.",
        "ports": [
          {
            "name": "in0",
            "direction": "input",
            "unit": "1",
            "description": "Branch 0; real signal.",
            "shape": [],
            "elementType": "real"
          },
          {
            "name": "out0",
            "direction": "output",
            "unit": "1",
            "description": "Branch 0; real signal.",
            "shape": [],
            "elementType": "real"
          },
          {
            "name": "out1",
            "direction": "output",
            "unit": "1",
            "description": "Branch 1; real signal.",
            "shape": [],
            "elementType": "real"
          }
        ],
        "parameters": [
          {
            "key": "selected",
            "label": "selected",
            "unit": "1",
            "default": 0,
            "description": "Explicit selected in the worked model."
          },
          {
            "key": "count",
            "label": "count",
            "unit": "1",
            "default": 2,
            "description": "Explicit count in the worked model."
          },
          {
            "key": "signal.quantity",
            "label": "signal quantity",
            "unit": "1",
            "default": "dimensionless",
            "description": "Explicit signal quantity in the worked model."
          },
          {
            "key": "signal.shape",
            "label": "signal shape",
            "unit": "1",
            "default": [],
            "description": "Explicit signal shape in the worked model."
          },
          {
            "key": "signal.elementType",
            "label": "signal element Type",
            "unit": "1",
            "default": "real",
            "description": "Explicit signal elementType in the worked model."
          }
        ],
        "equations": [
          "selected output = input"
        ],
        "example": {
          "title": "Manual variant sink — executable model",
          "text": "Choose the first path: input3 is doubled to6; the other branch is not executed.",
          "url": "https://design.lemonergy.com/cosim.html?example=routing-manual-variant-sink",
          "label": "Open Studio example",
          "inputs": [],
          "checks": [
            {
              "port": "Result",
              "label": "Result",
              "atS": 0.2,
              "value": 6,
              "unit": "1",
              "tolerance": 1e-09
            }
          ]
        },
        "limits": [
          "At most32 typed branches. Mid-run changes require a different runtime switch operation."
        ],
        "references": [],
        "referenceNote": "This compiler and software type contract is defined by the documented behavior and executable example; no external research result or full external API parity is claimed.",
        "caseIds": [
          "native-manual-variant-sink"
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "type": "manual-variant-sink",
        "implementationId": "manual-variant-sink",
        "url": "https://lemonergy.com/learn/glossary/blocks/manual-variant-sink/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/manual-variant-sink/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=routing-manual-variant-sink"
          ]
        },
        "studioHelp": {
          "type": "manual-variant-sink",
          "namespace": "signal",
          "slug": "signal-block-manual-variant-sink",
          "canonicalSlug": "manual-variant-sink",
          "existing": true,
          "dynamic": true,
          "scene": {
            "title": "Manual variant sink",
            "label": "Manual variant sink",
            "summary": "A manually configured compile-time output branch selection.",
            "details": [
              "Block type: manual-variant-sink.",
              "0 declared inputs and 0 declared outputs in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "condition → branch",
              "label": "Selection and control",
              "caption": "A manually configured compile-time output branch selection."
            },
            "inputs": [],
            "outputs": [],
            "parameters": [],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-manual-variant-sink/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:manual-variant-source",
      "type": "Block",
      "label": "Manual variant source",
      "properties": {
        "id": "manual-variant-source",
        "name": "Manual variant source",
        "kind": "studio",
        "summary": "A manually configured compile-time input branch selection.",
        "behavior": "A pre-run manual choice selects a single input branch and removes unused inactive producers.",
        "ports": [
          {
            "name": "in0",
            "direction": "input",
            "unit": "1",
            "description": "Branch 0; real signal.",
            "shape": [],
            "elementType": "real"
          },
          {
            "name": "in1",
            "direction": "input",
            "unit": "1",
            "description": "Branch 1; real signal.",
            "shape": [],
            "elementType": "real"
          },
          {
            "name": "out0",
            "direction": "output",
            "unit": "1",
            "description": "Branch 0; real signal.",
            "shape": [],
            "elementType": "real"
          }
        ],
        "parameters": [
          {
            "key": "selected",
            "label": "selected",
            "unit": "1",
            "default": 0,
            "description": "Explicit selected in the worked model."
          },
          {
            "key": "count",
            "label": "count",
            "unit": "1",
            "default": 2,
            "description": "Explicit count in the worked model."
          },
          {
            "key": "signal.quantity",
            "label": "signal quantity",
            "unit": "1",
            "default": "dimensionless",
            "description": "Explicit signal quantity in the worked model."
          },
          {
            "key": "signal.shape",
            "label": "signal shape",
            "unit": "1",
            "default": [],
            "description": "Explicit signal shape in the worked model."
          },
          {
            "key": "signal.elementType",
            "label": "signal element Type",
            "unit": "1",
            "default": "real",
            "description": "Explicit signal elementType in the worked model."
          }
        ],
        "equations": [
          "y = manually selected branch input"
        ],
        "example": {
          "title": "Manual variant source — executable model",
          "text": "Select source3 before the run; the following gain2 produces6.",
          "url": "https://design.lemonergy.com/cosim.html?example=routing-manual-variant-source",
          "label": "Open Studio example",
          "inputs": [],
          "checks": [
            {
              "port": "Result",
              "label": "Result",
              "atS": 0.2,
              "value": 6,
              "unit": "1",
              "tolerance": 1e-09
            }
          ]
        },
        "limits": [
          "The selection cannot change during execution. Types and dimensions must match across all branches."
        ],
        "references": [],
        "referenceNote": "This compiler and software type contract is defined by the documented behavior and executable example; no external research result or full external API parity is claimed.",
        "caseIds": [
          "native-manual-variant-source"
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "type": "manual-variant-source",
        "implementationId": "manual-variant-source",
        "url": "https://lemonergy.com/learn/glossary/blocks/manual-variant-source/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/manual-variant-source/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=routing-manual-variant-source"
          ]
        },
        "studioHelp": {
          "type": "manual-variant-source",
          "namespace": "signal",
          "slug": "signal-block-manual-variant-source",
          "canonicalSlug": "manual-variant-source",
          "existing": true,
          "dynamic": true,
          "scene": {
            "title": "Manual variant source",
            "label": "Manual variant source",
            "summary": "A manually configured compile-time input branch selection.",
            "details": [
              "Block type: manual-variant-source.",
              "0 declared inputs and 0 declared outputs in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "condition → branch",
              "label": "Selection and control",
              "caption": "A manually configured compile-time input branch selection."
            },
            "inputs": [],
            "outputs": [],
            "parameters": [],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-manual-variant-source/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:mpc",
      "type": "Block",
      "label": "Model predictive controller",
      "properties": {
        "id": "mpc",
        "kind": "studio",
        "name": "Model predictive controller",
        "summary": "Bounded linear, successive-linearisation landing or nonlinear shooting control with explicit solver status outputs.",
        "behavior": "Bounded linear, successive-linearisation landing or nonlinear shooting control with explicit solver status outputs.",
        "documentationSlug": "signal-block-mpc",
        "referenceOnly": true,
        "ports": [
          {
            "name": "x0",
            "direction": "input",
            "unit": "—",
            "description": "Number; Scalar; real. Received from a connected producer."
          },
          {
            "name": "r0",
            "direction": "input",
            "unit": "—",
            "description": "Number; Scalar; real. Received from a connected producer."
          },
          {
            "name": "u0",
            "direction": "output",
            "unit": "—",
            "description": "Number; Scalar; real. Produced for connected consumers."
          },
          {
            "name": "status",
            "direction": "output",
            "unit": "—",
            "description": "Number; Scalar; real. Produced for connected consumers."
          },
          {
            "name": "iterations",
            "direction": "output",
            "unit": "—",
            "description": "Number; Scalar; real. Produced for connected consumers."
          },
          {
            "name": "cost",
            "direction": "output",
            "unit": "—",
            "description": "Number; Scalar; real. Produced for connected consumers."
          },
          {
            "name": "residual",
            "direction": "output",
            "unit": "—",
            "description": "Number; Scalar; real. Produced for connected consumers."
          }
        ],
        "parameters": [
          {
            "key": "controller",
            "label": "Controller document",
            "unit": "",
            "default": "{\"model\":\"linear\",\"sampleTimeS\":0.02,\"nx\":1,\"nu\":1,\"ny\":1,\"Np\":10,\"Nc\":3,\"A\":[1],\"B\":[0.02],\"C\":[1],\"Q\":[1],\"R\":[0.01],\"S\":[0.1],\"umin\":[-10],\"umax\":[10],\"dumin\":[-2],\"dumax\":[2],\"ymin\":[-1e+30],\"ymax\":[1e+30],\"rho\":10,\"iterationCap\":400,\"tolerance\":0.000001,\"warmStart\":true,\"initialU\":[0],\"adaptations\":[],\"stateQuantities\":[\"dimensionless\"],\"outputQuantities\":[\"dimensionless\"],\"controlQuantities\":[\"dimensionless\"]}",
            "description": "Declared authoring field: Controller document."
          }
        ],
        "equations": [],
        "example": {
          "title": "Use this authoring component",
          "text": "Choose this component in the Studio library and configure its declared interface. This reference describes the authoring contract; it does not claim a standalone numerical validation or a measured result.",
          "url": "https://design.lemonergy.com/cosim",
          "label": "Open Studio"
        },
        "limits": [
          "The symbolic diagram describes the component and its declared interface. It is not a solved circuit or simulated output.",
          "Configured parameters and model connections determine the result. Check the complete model before interpreting its outputs."
        ],
        "evidence": [
          "docs/glossary/studio-help-catalog.json"
        ],
        "caseIds": [],
        "sourceRepository": "battery-design",
        "sourceRevision": "0a28f1a0a75a0447903b868cbcc734133a77a847",
        "reviewed": "2026-10-30",
        "type": "mpc",
        "implementationId": "mpc",
        "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-mpc/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/signal-block-mpc/",
        "sourceFile": "studio-help-catalog.json",
        "studioHelp": {
          "type": "mpc",
          "namespace": "signal",
          "slug": "signal-block-mpc",
          "canonicalSlug": "signal-block-mpc",
          "existing": false,
          "dynamic": false,
          "scene": {
            "title": "Model predictive controller",
            "label": "Model predictive controller",
            "summary": "Bounded linear, successive-linearisation landing or nonlinear shooting control with explicit solver status outputs.",
            "details": [
              "Block type: mpc.",
              "2 declared inputs and 5 declared outputs in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "predict → constrain → act",
              "label": "Predictive control",
              "caption": "Bounded linear, successive-linearisation landing or nonlinear shooting control with explicit solver status outputs."
            },
            "inputs": [
              {
                "id": "x0",
                "quantity": "dimensionless",
                "label": "x0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              },
              {
                "id": "r0",
                "quantity": "dimensionless",
                "label": "r0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              }
            ],
            "outputs": [
              {
                "id": "u0",
                "quantity": "dimensionless",
                "label": "u0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              },
              {
                "id": "status",
                "quantity": "dimensionless",
                "label": "status",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              },
              {
                "id": "iterations",
                "quantity": "dimensionless",
                "label": "iterations",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              },
              {
                "id": "cost",
                "quantity": "dimensionless",
                "label": "cost",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              },
              {
                "id": "residual",
                "quantity": "dimensionless",
                "label": "residual",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              }
            ],
            "parameters": [
              {
                "id": "controller",
                "label": "Controller document",
                "unit": "",
                "value": "{\"model\":\"linear\",\"sampleTimeS\":0.02,\"nx\":1,\"nu\":1,\"ny\":1,\"Np\":10,\"Nc\":3,\"A\":[1],\"B\":[0.02],\"C\":[1],\"Q\":[1],\"R\":[0.01],\"S\":[0.1],\"umin\":[-10],\"umax\":[10],\"dumin\":[-2],\"dumax\":[2],\"ymin\":[-1e+30],\"ymax\":[1e+30],\"rho\":10,\"iterationCap\":400,\"tolerance\":0.000001,\"warmStart\":true,\"initialU\":[0],\"adaptations\":[],\"stateQuantities\":[\"dimensionless\"],\"outputQuantities\":[\"dimensionless\"],\"controlQuantities\":[\"dimensionless\"]}"
              }
            ],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-mpc/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:native-arithmetic-shift",
      "type": "Block",
      "label": "Arithmetic bit shift",
      "properties": {
        "id": "native-arithmetic-shift",
        "name": "Arithmetic bit shift",
        "kind": "studio",
        "summary": "Shifts signed 32-bit words with explicit arithmetic-right and wrapping-left rules.",
        "behavior": "y = signed 32 arithmetic right shift, or wrapping left shift. The worked example connects this operation to signals in Lemonergy Studio.",
        "ports": [
          {
            "name": "in0",
            "direction": "input",
            "unit": "1",
            "description": "Signed word; i32 scalar.",
            "shape": [],
            "elementType": "i32"
          },
          {
            "name": "out0",
            "direction": "output",
            "unit": "1",
            "description": "Result; i32 scalar.",
            "shape": [],
            "elementType": "i32"
          }
        ],
        "parameters": [
          {
            "key": "params[0]",
            "label": "Shift count",
            "unit": "1",
            "default": -1,
            "description": "Positive left (32-bit wrapping); negative arithmetic right."
          }
        ],
        "equations": [
          "y = signed 32 arithmetic right shift, or wrapping left shift"
        ],
        "example": {
          "title": "Arithmetic bit shift — worked example",
          "text": "Signed word = -8. Result at 0 s = -4.",
          "url": "https://design.lemonergy.com/cosim.html?example=block-native-arithmetic-shift",
          "label": "Open Studio example",
          "inputs": [
            {
              "port": "in0",
              "label": "Signed word",
              "value": -8,
              "unit": "1"
            }
          ],
          "checks": [
            {
              "port": "out0",
              "label": "Result",
              "atS": 0,
              "value": -4,
              "unit": "1",
              "tolerance": 1e-08
            }
          ]
        },
        "limits": [
          "Signed32-bit values, shifts -31..31; arithmetic right shift and wrapping left shift.",
          "Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed."
        ],
        "references": [],
        "referenceNote": "This software operation and its numerical conventions are defined by the public contract and worked example; no external research result is claimed.",
        "caseIds": [
          "native-native-arithmetic-shift"
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "exampleTraces": [
          {
            "id": "native-arithmetic-shift",
            "url": "https://lemonergy.com/learn/glossary/api/traces/native-arithmetic-shift.json?v=09915cb75b44",
            "title": "Arithmetic bit shift recorded example",
            "exampleId": "block-native-arithmetic-shift",
            "source": "Executed synthetic Lemonergy Studio example",
            "recordedOn": "2026-10-28",
            "points": 2,
            "channels": 1,
            "omittedChannels": 0,
            "interpolation": "linear",
            "solver": {
              "method": "dormand-prince-45",
              "reason": "no-continuous-states"
            }
          }
        ],
        "type": "native-arithmetic-shift",
        "implementationId": "native-arithmetic-shift",
        "url": "https://lemonergy.com/learn/glossary/blocks/native-arithmetic-shift/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/native-arithmetic-shift/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=block-native-arithmetic-shift"
          ]
        },
        "studioHelp": {
          "type": "native-arithmetic-shift",
          "namespace": "signal",
          "slug": "signal-block-native-arithmetic-shift",
          "canonicalSlug": "native-arithmetic-shift",
          "existing": true,
          "dynamic": false,
          "scene": {
            "title": "Arithmetic bit shift",
            "label": "Arithmetic bit shift",
            "summary": "Shifts signed 32-bit words with explicit arithmetic-right and wrapping-left rules.",
            "details": [
              "Block type: native-arithmetic-shift.",
              "1 declared input and 1 declared output in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "input → condition → result",
              "label": "Arithmetic bit shift",
              "caption": "Shifts signed 32-bit words with explicit arithmetic-right and wrapping-left rules."
            },
            "inputs": [
              {
                "label": "Signed word",
                "shape": [],
                "quantity": "dimensionless",
                "elementType": "i32",
                "id": "in0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "i32"
              }
            ],
            "outputs": [
              {
                "label": "Result",
                "shape": [],
                "quantity": "dimensionless",
                "elementType": "i32",
                "id": "out0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "i32"
              }
            ],
            "parameters": [
              {
                "id": "config",
                "label": "Configuration",
                "unit": "",
                "value": "{\"inputs\":[{\"label\":\"Signed word\",\"shape\":[],\"quantity\":\"dimensionless\",\"elementType\":\"i32\"}],\"outputs\":[{\"label\":\"Result\",\"shape\":[],\"quantity\":\"dimensionless\",\"elementType\":\"i32\"}],\"sampleTimeS\":0,\"params\":[-1],\"tables\":[]}"
              }
            ],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-native-arithmetic-shift/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:native-assertion",
      "type": "Block",
      "label": "Assertion",
      "properties": {
        "id": "native-assertion",
        "name": "Assertion",
        "kind": "studio",
        "summary": "Stops the simulation if its Boolean condition is false.",
        "behavior": "Pass if condition = true; otherwise return an assertion failure.",
        "ports": [
          {
            "name": "in0",
            "direction": "input",
            "unit": "1",
            "description": "Condition; bool scalar.",
            "shape": [],
            "elementType": "bool"
          },
          {
            "name": "out0",
            "direction": "output",
            "unit": "1",
            "description": "Passed; bool scalar.",
            "shape": [],
            "elementType": "bool"
          }
        ],
        "parameters": [],
        "equations": [
          "Pass if condition = true; otherwise return an assertion failure"
        ],
        "example": {
          "title": "Assertion — worked example",
          "text": "Condition = 1. Passed at 0 s = 1.",
          "url": "https://design.lemonergy.com/cosim.html?example=block-native-assertion",
          "label": "Open Studio example",
          "inputs": [
            {
              "port": "in0",
              "label": "Condition",
              "value": 1,
              "unit": "1"
            }
          ],
          "checks": [
            {
              "port": "out0",
              "label": "Passed",
              "atS": 0,
              "value": 1,
              "unit": "1",
              "tolerance": 1e-09
            }
          ]
        },
        "limits": [
          "A failed assertion is an error. Use Stop simulation for successful conditional completion."
        ],
        "references": [],
        "referenceNote": "This software operation is defined by its public contract and worked example; no external research result is claimed.",
        "caseIds": [
          "native-native-assertion"
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "exampleTraces": [
          {
            "id": "native-assertion",
            "url": "https://lemonergy.com/learn/glossary/api/traces/native-assertion.json?v=7c7970acd38e",
            "title": "Assertion recorded example",
            "exampleId": "block-native-assertion",
            "source": "Executed synthetic Lemonergy Studio example",
            "recordedOn": "2026-10-28",
            "points": 2,
            "channels": 1,
            "omittedChannels": 0,
            "interpolation": "linear",
            "solver": {
              "method": "dormand-prince-45",
              "reason": "no-continuous-states"
            }
          }
        ],
        "type": "native-assertion",
        "implementationId": "native-assertion",
        "url": "https://lemonergy.com/learn/glossary/blocks/native-assertion/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/native-assertion/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=block-native-assertion"
          ]
        },
        "studioHelp": {
          "type": "native-assertion",
          "namespace": "signal",
          "slug": "signal-block-native-assertion",
          "canonicalSlug": "native-assertion",
          "existing": true,
          "dynamic": false,
          "scene": {
            "title": "Assertion",
            "label": "Assertion",
            "summary": "Stops the simulation if its Boolean condition is false.",
            "details": [
              "Block type: native-assertion.",
              "1 declared input and 1 declared output in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "input → condition → result",
              "label": "Assertion",
              "caption": "Stops the simulation if its Boolean condition is false."
            },
            "inputs": [
              {
                "label": "Condition",
                "shape": [],
                "elementType": "bool",
                "quantity": "dimensionless",
                "id": "in0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "bool"
              }
            ],
            "outputs": [
              {
                "label": "Passed",
                "shape": [],
                "elementType": "bool",
                "quantity": "dimensionless",
                "id": "out0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "bool"
              }
            ],
            "parameters": [
              {
                "id": "config",
                "label": "Configuration",
                "unit": "",
                "value": "{\"inputs\":[{\"label\":\"Condition\",\"shape\":[],\"elementType\":\"bool\",\"quantity\":\"dimensionless\"}],\"outputs\":[{\"label\":\"Passed\",\"shape\":[],\"elementType\":\"bool\",\"quantity\":\"dimensionless\"}],\"params\":[],\"sampleTimeS\":0}"
              }
            ],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-native-assertion/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:native-bit-clear",
      "type": "Block",
      "label": "Clear bit",
      "properties": {
        "id": "native-bit-clear",
        "name": "Clear bit",
        "kind": "studio",
        "summary": "Clears a selected bit of an unsigned 32-bit word.",
        "behavior": "y = word AND NOT(1 << bit). The worked example connects this operation to signals in Lemonergy Studio.",
        "ports": [
          {
            "name": "in0",
            "direction": "input",
            "unit": "1",
            "description": "Word; u32 scalar.",
            "shape": [],
            "elementType": "u32"
          },
          {
            "name": "out0",
            "direction": "output",
            "unit": "1",
            "description": "Result; u32 scalar.",
            "shape": [],
            "elementType": "u32"
          }
        ],
        "parameters": [
          {
            "key": "params[0]",
            "label": "Bit index",
            "unit": "1",
            "default": 1,
            "description": "Zero-based bit, 0–31."
          }
        ],
        "equations": [
          "y = word AND NOT(1 << bit)"
        ],
        "example": {
          "title": "Clear bit — worked example",
          "text": "Word = 7. Result at 0 s = 5.",
          "url": "https://design.lemonergy.com/cosim.html?example=block-native-bit-clear",
          "label": "Open Studio example",
          "inputs": [
            {
              "port": "in0",
              "label": "Word",
              "value": 7,
              "unit": "1"
            }
          ],
          "checks": [
            {
              "port": "out0",
              "label": "Result",
              "atS": 0,
              "value": 5,
              "unit": "1",
              "tolerance": 1e-08
            }
          ]
        },
        "limits": [
          "Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed."
        ],
        "references": [],
        "referenceNote": "This software operation and its numerical conventions are defined by the public contract and worked example; no external research result is claimed.",
        "caseIds": [
          "native-native-bit-clear"
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "exampleTraces": [
          {
            "id": "native-bit-clear",
            "url": "https://lemonergy.com/learn/glossary/api/traces/native-bit-clear.json?v=e7b136b4aba2",
            "title": "Clear bit recorded example",
            "exampleId": "block-native-bit-clear",
            "source": "Executed synthetic Lemonergy Studio example",
            "recordedOn": "2026-10-28",
            "points": 2,
            "channels": 1,
            "omittedChannels": 0,
            "interpolation": "linear",
            "solver": {
              "method": "dormand-prince-45",
              "reason": "no-continuous-states"
            }
          }
        ],
        "type": "native-bit-clear",
        "implementationId": "native-bit-clear",
        "url": "https://lemonergy.com/learn/glossary/blocks/native-bit-clear/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/native-bit-clear/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=block-native-bit-clear"
          ]
        },
        "studioHelp": {
          "type": "native-bit-clear",
          "namespace": "signal",
          "slug": "signal-block-native-bit-clear",
          "canonicalSlug": "native-bit-clear",
          "existing": true,
          "dynamic": false,
          "scene": {
            "title": "Clear bit",
            "label": "Clear bit",
            "summary": "Clears a selected bit of an unsigned 32-bit word.",
            "details": [
              "Block type: native-bit-clear.",
              "1 declared input and 1 declared output in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "input → condition → result",
              "label": "Clear bit",
              "caption": "Clears a selected bit of an unsigned 32-bit word."
            },
            "inputs": [
              {
                "label": "Word",
                "shape": [],
                "quantity": "dimensionless",
                "elementType": "u32",
                "id": "in0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "u32"
              }
            ],
            "outputs": [
              {
                "label": "Result",
                "shape": [],
                "quantity": "dimensionless",
                "elementType": "u32",
                "id": "out0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "u32"
              }
            ],
            "parameters": [
              {
                "id": "config",
                "label": "Configuration",
                "unit": "",
                "value": "{\"inputs\":[{\"label\":\"Word\",\"shape\":[],\"quantity\":\"dimensionless\",\"elementType\":\"u32\"}],\"outputs\":[{\"label\":\"Result\",\"shape\":[],\"quantity\":\"dimensionless\",\"elementType\":\"u32\"}],\"sampleTimeS\":0,\"params\":[1],\"tables\":[]}"
              }
            ],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-native-bit-clear/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:native-bit-set",
      "type": "Block",
      "label": "Set bit",
      "properties": {
        "id": "native-bit-set",
        "name": "Set bit",
        "kind": "studio",
        "summary": "Sets a selected bit of an unsigned 32-bit word.",
        "behavior": "y = word OR (1 << bit). The worked example connects this operation to signals in Lemonergy Studio.",
        "ports": [
          {
            "name": "in0",
            "direction": "input",
            "unit": "1",
            "description": "Word; u32 scalar.",
            "shape": [],
            "elementType": "u32"
          },
          {
            "name": "out0",
            "direction": "output",
            "unit": "1",
            "description": "Result; u32 scalar.",
            "shape": [],
            "elementType": "u32"
          }
        ],
        "parameters": [
          {
            "key": "params[0]",
            "label": "Bit index",
            "unit": "1",
            "default": 3,
            "description": "Zero-based bit, 0–31."
          }
        ],
        "equations": [
          "y = word OR (1 << bit)"
        ],
        "example": {
          "title": "Set bit — worked example",
          "text": "Word = 1. Result at 0 s = 9.",
          "url": "https://design.lemonergy.com/cosim.html?example=block-native-bit-set",
          "label": "Open Studio example",
          "inputs": [
            {
              "port": "in0",
              "label": "Word",
              "value": 1,
              "unit": "1"
            }
          ],
          "checks": [
            {
              "port": "out0",
              "label": "Result",
              "atS": 0,
              "value": 9,
              "unit": "1",
              "tolerance": 1e-08
            }
          ]
        },
        "limits": [
          "Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed."
        ],
        "references": [],
        "referenceNote": "This software operation and its numerical conventions are defined by the public contract and worked example; no external research result is claimed.",
        "caseIds": [
          "native-native-bit-set"
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "exampleTraces": [
          {
            "id": "native-bit-set",
            "url": "https://lemonergy.com/learn/glossary/api/traces/native-bit-set.json?v=3985814b94bc",
            "title": "Set bit recorded example",
            "exampleId": "block-native-bit-set",
            "source": "Executed synthetic Lemonergy Studio example",
            "recordedOn": "2026-10-28",
            "points": 2,
            "channels": 1,
            "omittedChannels": 0,
            "interpolation": "linear",
            "solver": {
              "method": "dormand-prince-45",
              "reason": "no-continuous-states"
            }
          }
        ],
        "type": "native-bit-set",
        "implementationId": "native-bit-set",
        "url": "https://lemonergy.com/learn/glossary/blocks/native-bit-set/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/native-bit-set/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=block-native-bit-set"
          ]
        },
        "studioHelp": {
          "type": "native-bit-set",
          "namespace": "signal",
          "slug": "signal-block-native-bit-set",
          "canonicalSlug": "native-bit-set",
          "existing": true,
          "dynamic": false,
          "scene": {
            "title": "Set bit",
            "label": "Set bit",
            "summary": "Sets a selected bit of an unsigned 32-bit word.",
            "details": [
              "Block type: native-bit-set.",
              "1 declared input and 1 declared output in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "input → condition → result",
              "label": "Set bit",
              "caption": "Sets a selected bit of an unsigned 32-bit word."
            },
            "inputs": [
              {
                "label": "Word",
                "shape": [],
                "quantity": "dimensionless",
                "elementType": "u32",
                "id": "in0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "u32"
              }
            ],
            "outputs": [
              {
                "label": "Result",
                "shape": [],
                "quantity": "dimensionless",
                "elementType": "u32",
                "id": "out0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "u32"
              }
            ],
            "parameters": [
              {
                "id": "config",
                "label": "Configuration",
                "unit": "",
                "value": "{\"inputs\":[{\"label\":\"Word\",\"shape\":[],\"quantity\":\"dimensionless\",\"elementType\":\"u32\"}],\"outputs\":[{\"label\":\"Result\",\"shape\":[],\"quantity\":\"dimensionless\",\"elementType\":\"u32\"}],\"sampleTimeS\":0,\"params\":[3],\"tables\":[]}"
              }
            ],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-native-bit-set/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:native-bitwise-operator",
      "type": "Block",
      "label": "Bitwise operator",
      "properties": {
        "id": "native-bitwise-operator",
        "name": "Bitwise operator",
        "kind": "studio",
        "summary": "Applies bitwise logic to unsigned 32-bit words.",
        "behavior": "y = bitwise AND, OR, XOR or NOT. The worked example connects this operation to signals in Lemonergy Studio.",
        "ports": [
          {
            "name": "in0",
            "direction": "input",
            "unit": "1",
            "description": "A; u32 scalar.",
            "shape": [],
            "elementType": "u32"
          },
          {
            "name": "in1",
            "direction": "input",
            "unit": "1",
            "description": "B; u32 scalar.",
            "shape": [],
            "elementType": "u32"
          },
          {
            "name": "out0",
            "direction": "output",
            "unit": "1",
            "description": "Result; u32 scalar.",
            "shape": [],
            "elementType": "u32"
          }
        ],
        "parameters": [
          {
            "key": "params[0]",
            "label": "Operation",
            "unit": "1",
            "default": 2,
            "description": "0 AND; 1 OR; 2 XOR; 3 NOT A."
          }
        ],
        "equations": [
          "y = bitwise AND, OR, XOR or NOT"
        ],
        "example": {
          "title": "Bitwise operator — worked example",
          "text": "A = 12; B = 10. Result at 0 s = 6.",
          "url": "https://design.lemonergy.com/cosim.html?example=block-native-bitwise-operator",
          "label": "Open Studio example",
          "inputs": [
            {
              "port": "in0",
              "label": "A",
              "value": 12,
              "unit": "1"
            },
            {
              "port": "in1",
              "label": "B",
              "value": 10,
              "unit": "1"
            }
          ],
          "checks": [
            {
              "port": "out0",
              "label": "Result",
              "atS": 0,
              "value": 6,
              "unit": "1",
              "tolerance": 1e-08
            }
          ]
        },
        "limits": [
          "Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed."
        ],
        "references": [],
        "referenceNote": "This software operation and its numerical conventions are defined by the public contract and worked example; no external research result is claimed.",
        "caseIds": [
          "native-native-bitwise-operator"
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "exampleTraces": [
          {
            "id": "native-bitwise-operator",
            "url": "https://lemonergy.com/learn/glossary/api/traces/native-bitwise-operator.json?v=c001f83cd219",
            "title": "Bitwise operator recorded example",
            "exampleId": "block-native-bitwise-operator",
            "source": "Executed synthetic Lemonergy Studio example",
            "recordedOn": "2026-10-28",
            "points": 2,
            "channels": 1,
            "omittedChannels": 0,
            "interpolation": "linear",
            "solver": {
              "method": "dormand-prince-45",
              "reason": "no-continuous-states"
            }
          }
        ],
        "type": "native-bitwise-operator",
        "implementationId": "native-bitwise-operator",
        "url": "https://lemonergy.com/learn/glossary/blocks/native-bitwise-operator/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/native-bitwise-operator/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=block-native-bitwise-operator"
          ]
        },
        "studioHelp": {
          "type": "native-bitwise-operator",
          "namespace": "signal",
          "slug": "signal-block-native-bitwise-operator",
          "canonicalSlug": "native-bitwise-operator",
          "existing": true,
          "dynamic": false,
          "scene": {
            "title": "Bitwise operator",
            "label": "Bitwise operator",
            "summary": "Applies bitwise logic to unsigned 32-bit words.",
            "details": [
              "Block type: native-bitwise-operator.",
              "2 declared inputs and 1 declared output in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "input → condition → result",
              "label": "Bitwise operator",
              "caption": "Applies bitwise logic to unsigned 32-bit words."
            },
            "inputs": [
              {
                "label": "A",
                "shape": [],
                "quantity": "dimensionless",
                "elementType": "u32",
                "id": "in0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "u32"
              },
              {
                "label": "B",
                "shape": [],
                "quantity": "dimensionless",
                "elementType": "u32",
                "id": "in1",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "u32"
              }
            ],
            "outputs": [
              {
                "label": "Result",
                "shape": [],
                "quantity": "dimensionless",
                "elementType": "u32",
                "id": "out0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "u32"
              }
            ],
            "parameters": [
              {
                "id": "config",
                "label": "Configuration",
                "unit": "",
                "value": "{\"inputs\":[{\"label\":\"A\",\"shape\":[],\"quantity\":\"dimensionless\",\"elementType\":\"u32\"},{\"label\":\"B\",\"shape\":[],\"quantity\":\"dimensionless\",\"elementType\":\"u32\"}],\"outputs\":[{\"label\":\"Result\",\"shape\":[],\"quantity\":\"dimensionless\",\"elementType\":\"u32\"}],\"sampleTimeS\":0,\"params\":[2],\"tables\":[]}"
              }
            ],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-native-bitwise-operator/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:native-boolean-operator",
      "type": "Block",
      "label": "Boolean operator",
      "properties": {
        "id": "native-boolean-operator",
        "name": "Boolean operator",
        "kind": "studio",
        "summary": "Combines Boolean arrays using AND, OR, XOR, NAND, NOR or inversion.",
        "behavior": "y = A AND B, A OR B, A XOR B, NAND, NOR, or NOT A. The worked example connects this operation to signals in Lemonergy Studio.",
        "ports": [
          {
            "name": "in0",
            "direction": "input",
            "unit": "1",
            "description": "A; bool 3 array.",
            "shape": [
              3
            ],
            "elementType": "bool"
          },
          {
            "name": "in1",
            "direction": "input",
            "unit": "1",
            "description": "B; bool 3 array.",
            "shape": [
              3
            ],
            "elementType": "bool"
          },
          {
            "name": "out0",
            "direction": "output",
            "unit": "1",
            "description": "Result; bool 3 array.",
            "shape": [
              3
            ],
            "elementType": "bool"
          }
        ],
        "parameters": [
          {
            "key": "params[0]",
            "label": "Operation",
            "unit": "1",
            "default": 0,
            "description": "0 AND; 1 OR; 2 XOR; 3 NAND; 4 NOR; 5 NOT A."
          }
        ],
        "equations": [
          "y = A AND B, A OR B, A XOR B, NAND, NOR, or NOT A"
        ],
        "example": {
          "title": "Boolean operator — worked example",
          "text": "A = [1,0,1]; B = [1,1,0]. Result at 0 s = [1,0,0].",
          "url": "https://design.lemonergy.com/cosim.html?example=block-native-boolean-operator",
          "label": "Open Studio example",
          "inputs": [
            {
              "port": "in0",
              "label": "A",
              "value": [
                1,
                0,
                1
              ],
              "unit": "1"
            },
            {
              "port": "in1",
              "label": "B",
              "value": [
                1,
                1,
                0
              ],
              "unit": "1"
            }
          ],
          "checks": [
            {
              "port": "out0",
              "label": "Result",
              "atS": 0,
              "value": [
                1,
                0,
                0
              ],
              "unit": "1",
              "tolerance": 1e-08
            }
          ]
        },
        "limits": [
          "Boolean elementwise two-input AND/OR/XOR/NAND/NOR or NOT A; no integer truthiness coercion.",
          "Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed."
        ],
        "references": [],
        "referenceNote": "This software operation and its numerical conventions are defined by the public contract and worked example; no external research result is claimed.",
        "caseIds": [
          "native-native-boolean-operator"
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "exampleTraces": [
          {
            "id": "native-boolean-operator",
            "url": "https://lemonergy.com/learn/glossary/api/traces/native-boolean-operator.json?v=67ad38645113",
            "title": "Boolean operator recorded example",
            "exampleId": "block-native-boolean-operator",
            "source": "Executed synthetic Lemonergy Studio example",
            "recordedOn": "2026-10-28",
            "points": 2,
            "channels": 3,
            "omittedChannels": 0,
            "interpolation": "linear",
            "solver": {
              "method": "dormand-prince-45",
              "reason": "no-continuous-states"
            }
          }
        ],
        "type": "native-boolean-operator",
        "implementationId": "native-boolean-operator",
        "url": "https://lemonergy.com/learn/glossary/blocks/native-boolean-operator/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/native-boolean-operator/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=block-native-boolean-operator"
          ]
        },
        "studioHelp": {
          "type": "native-boolean-operator",
          "namespace": "signal",
          "slug": "signal-block-native-boolean-operator",
          "canonicalSlug": "native-boolean-operator",
          "existing": true,
          "dynamic": false,
          "scene": {
            "title": "Boolean operator",
            "label": "Boolean operator",
            "summary": "Combines Boolean arrays using AND, OR, XOR, NAND, NOR or inversion.",
            "details": [
              "Block type: native-boolean-operator.",
              "2 declared inputs and 1 declared output in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "input → condition → result",
              "label": "Boolean operator",
              "caption": "Combines Boolean arrays using AND, OR, XOR, NAND, NOR or inversion."
            },
            "inputs": [
              {
                "label": "A",
                "shape": [
                  3
                ],
                "quantity": "dimensionless",
                "elementType": "bool",
                "id": "in0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Array 3",
                "elementLabel": "bool"
              },
              {
                "label": "B",
                "shape": [
                  3
                ],
                "quantity": "dimensionless",
                "elementType": "bool",
                "id": "in1",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Array 3",
                "elementLabel": "bool"
              }
            ],
            "outputs": [
              {
                "label": "Result",
                "shape": [
                  3
                ],
                "quantity": "dimensionless",
                "elementType": "bool",
                "id": "out0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Array 3",
                "elementLabel": "bool"
              }
            ],
            "parameters": [
              {
                "id": "config",
                "label": "Configuration",
                "unit": "",
                "value": "{\"inputs\":[{\"label\":\"A\",\"shape\":[3],\"quantity\":\"dimensionless\",\"elementType\":\"bool\"},{\"label\":\"B\",\"shape\":[3],\"quantity\":\"dimensionless\",\"elementType\":\"bool\"}],\"outputs\":[{\"label\":\"Result\",\"shape\":[3],\"quantity\":\"dimensionless\",\"elementType\":\"bool\"}],\"sampleTimeS\":0,\"params\":[0],\"tables\":[]}"
              }
            ],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-native-boolean-operator/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:native-check-dynamic-gap",
      "type": "Block",
      "label": "Dynamic forbidden interval check",
      "properties": {
        "id": "native-check-dynamic-gap",
        "name": "Dynamic forbidden interval check",
        "kind": "studio",
        "summary": "Checks that a value is outside the closed interval supplied by the current lower and upper inputs.",
        "behavior": "pass = (value < connected lower OR value > connected upper).",
        "ports": [
          {
            "name": "in0",
            "direction": "input",
            "unit": "1",
            "description": "Value; real scalar.",
            "shape": [],
            "elementType": "real"
          },
          {
            "name": "in1",
            "direction": "input",
            "unit": "1",
            "description": "Lower bound; real scalar.",
            "shape": [],
            "elementType": "real"
          },
          {
            "name": "in2",
            "direction": "input",
            "unit": "1",
            "description": "Upper bound; real scalar.",
            "shape": [],
            "elementType": "real"
          },
          {
            "name": "out0",
            "direction": "output",
            "unit": "1",
            "description": "Outside forbidden interval; bool scalar.",
            "shape": [],
            "elementType": "bool"
          }
        ],
        "parameters": [],
        "equations": [
          "pass = (value < connected lower OR value > connected upper)"
        ],
        "example": {
          "title": "Dynamic forbidden interval check — worked example",
          "text": "Value = 5; Lower bound = 2; Upper bound = 4. Outside forbidden interval at 0 s = 1.",
          "url": "https://design.lemonergy.com/cosim.html?example=block-native-check-dynamic-gap",
          "label": "Open Studio example",
          "inputs": [
            {
              "port": "in0",
              "label": "Value",
              "value": 5,
              "unit": "1"
            },
            {
              "port": "in1",
              "label": "Lower bound",
              "value": 2,
              "unit": "1"
            },
            {
              "port": "in2",
              "label": "Upper bound",
              "value": 4,
              "unit": "1"
            }
          ],
          "checks": [
            {
              "port": "out0",
              "label": "Outside forbidden interval",
              "atS": 0,
              "value": 1,
              "unit": "1",
              "tolerance": 1e-09
            }
          ]
        },
        "limits": [
          "Reversed bounds are invalid; both forbidden boundaries are excluded from passing values."
        ],
        "references": [],
        "referenceNote": "This software operation is defined by its public contract and worked example; no external research result is claimed.",
        "caseIds": [
          "native-native-check-dynamic-gap"
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "exampleTraces": [
          {
            "id": "native-check-dynamic-gap",
            "url": "https://lemonergy.com/learn/glossary/api/traces/native-check-dynamic-gap.json?v=46080a76f41b",
            "title": "Dynamic forbidden interval check recorded example",
            "exampleId": "block-native-check-dynamic-gap",
            "source": "Executed synthetic Lemonergy Studio example",
            "recordedOn": "2026-10-28",
            "points": 2,
            "channels": 1,
            "omittedChannels": 0,
            "interpolation": "linear",
            "solver": {
              "method": "dormand-prince-45",
              "reason": "no-continuous-states"
            }
          }
        ],
        "type": "native-check-dynamic-gap",
        "implementationId": "native-check-dynamic-gap",
        "url": "https://lemonergy.com/learn/glossary/blocks/native-check-dynamic-gap/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/native-check-dynamic-gap/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=block-native-check-dynamic-gap"
          ]
        },
        "studioHelp": {
          "type": "native-check-dynamic-gap",
          "namespace": "signal",
          "slug": "signal-block-native-check-dynamic-gap",
          "canonicalSlug": "native-check-dynamic-gap",
          "existing": true,
          "dynamic": false,
          "scene": {
            "title": "Dynamic forbidden interval check",
            "label": "Dynamic forbidden interval check",
            "summary": "Checks that a value is outside the closed interval supplied by the current lower and upper inputs.",
            "details": [
              "Block type: native-check-dynamic-gap.",
              "3 declared inputs and 1 declared output in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "input → condition → result",
              "label": "Dynamic forbidden interval check",
              "caption": "Checks that a value is outside the closed interval supplied by the current lower and upper inputs."
            },
            "inputs": [
              {
                "label": "Value",
                "shape": [],
                "elementType": "real",
                "quantity": "dimensionless",
                "id": "in0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              },
              {
                "label": "Lower bound",
                "shape": [],
                "elementType": "real",
                "quantity": "dimensionless",
                "id": "in1",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              },
              {
                "label": "Upper bound",
                "shape": [],
                "elementType": "real",
                "quantity": "dimensionless",
                "id": "in2",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              }
            ],
            "outputs": [
              {
                "label": "Outside forbidden interval",
                "shape": [],
                "elementType": "bool",
                "quantity": "dimensionless",
                "id": "out0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "bool"
              }
            ],
            "parameters": [
              {
                "id": "config",
                "label": "Configuration",
                "unit": "",
                "value": "{\"inputs\":[{\"label\":\"Value\",\"shape\":[],\"elementType\":\"real\",\"quantity\":\"dimensionless\"},{\"label\":\"Lower bound\",\"shape\":[],\"elementType\":\"real\",\"quantity\":\"dimensionless\"},{\"label\":\"Upper bound\",\"shape\":[],\"elementType\":\"real\",\"quantity\":\"dimensionless\"}],\"outputs\":[{\"label\":\"Outside forbidden interval\",\"shape\":[],\"elementType\":\"bool\",\"quantity\":\"dimensionless\"}],\"params\":[],\"sampleTimeS\":0}"
              }
            ],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-native-check-dynamic-gap/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:native-check-dynamic-lower",
      "type": "Block",
      "label": "Dynamic lower-bound check",
      "properties": {
        "id": "native-check-dynamic-lower",
        "name": "Dynamic lower-bound check",
        "kind": "studio",
        "summary": "Checks a scalar against a connected inclusive lower bound.",
        "behavior": "pass = (value ≥ connected lower).",
        "ports": [
          {
            "name": "in0",
            "direction": "input",
            "unit": "1",
            "description": "Value; real scalar.",
            "shape": [],
            "elementType": "real"
          },
          {
            "name": "in1",
            "direction": "input",
            "unit": "1",
            "description": "Lower bound; real scalar.",
            "shape": [],
            "elementType": "real"
          },
          {
            "name": "out0",
            "direction": "output",
            "unit": "1",
            "description": "Pass; bool scalar.",
            "shape": [],
            "elementType": "bool"
          }
        ],
        "parameters": [],
        "equations": [
          "pass = (value ≥ connected lower)"
        ],
        "example": {
          "title": "Dynamic lower-bound check — worked example",
          "text": "Value = 2; Lower bound = 3. Pass at 0 s = 0.",
          "url": "https://design.lemonergy.com/cosim.html?example=block-native-check-dynamic-lower",
          "label": "Open Studio example",
          "inputs": [
            {
              "port": "in0",
              "label": "Value",
              "value": 2,
              "unit": "1"
            },
            {
              "port": "in1",
              "label": "Lower bound",
              "value": 3,
              "unit": "1"
            }
          ],
          "checks": [
            {
              "port": "out0",
              "label": "Pass",
              "atS": 0,
              "value": 0,
              "unit": "1",
              "tolerance": 1e-09
            }
          ]
        },
        "limits": [
          "Scalar real inputs with the same quantity; equality passes."
        ],
        "references": [],
        "referenceNote": "This software operation is defined by its public contract and worked example; no external research result is claimed.",
        "caseIds": [
          "native-native-check-dynamic-lower"
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "exampleTraces": [
          {
            "id": "native-check-dynamic-lower",
            "url": "https://lemonergy.com/learn/glossary/api/traces/native-check-dynamic-lower.json?v=8ae5f04a9695",
            "title": "Dynamic lower-bound check recorded example",
            "exampleId": "block-native-check-dynamic-lower",
            "source": "Executed synthetic Lemonergy Studio example",
            "recordedOn": "2026-10-28",
            "points": 2,
            "channels": 1,
            "omittedChannels": 0,
            "interpolation": "linear",
            "solver": {
              "method": "dormand-prince-45",
              "reason": "no-continuous-states"
            }
          }
        ],
        "type": "native-check-dynamic-lower",
        "implementationId": "native-check-dynamic-lower",
        "url": "https://lemonergy.com/learn/glossary/blocks/native-check-dynamic-lower/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/native-check-dynamic-lower/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=block-native-check-dynamic-lower"
          ]
        },
        "studioHelp": {
          "type": "native-check-dynamic-lower",
          "namespace": "signal",
          "slug": "signal-block-native-check-dynamic-lower",
          "canonicalSlug": "native-check-dynamic-lower",
          "existing": true,
          "dynamic": false,
          "scene": {
            "title": "Dynamic lower-bound check",
            "label": "Dynamic lower-bound check",
            "summary": "Checks a scalar against a connected inclusive lower bound.",
            "details": [
              "Block type: native-check-dynamic-lower.",
              "2 declared inputs and 1 declared output in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "input → condition → result",
              "label": "Dynamic lower-bound check",
              "caption": "Checks a scalar against a connected inclusive lower bound."
            },
            "inputs": [
              {
                "label": "Value",
                "shape": [],
                "elementType": "real",
                "quantity": "dimensionless",
                "id": "in0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              },
              {
                "label": "Lower bound",
                "shape": [],
                "elementType": "real",
                "quantity": "dimensionless",
                "id": "in1",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              }
            ],
            "outputs": [
              {
                "label": "Pass",
                "shape": [],
                "elementType": "bool",
                "quantity": "dimensionless",
                "id": "out0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "bool"
              }
            ],
            "parameters": [
              {
                "id": "config",
                "label": "Configuration",
                "unit": "",
                "value": "{\"inputs\":[{\"label\":\"Value\",\"shape\":[],\"elementType\":\"real\",\"quantity\":\"dimensionless\"},{\"label\":\"Lower bound\",\"shape\":[],\"elementType\":\"real\",\"quantity\":\"dimensionless\"}],\"outputs\":[{\"label\":\"Pass\",\"shape\":[],\"elementType\":\"bool\",\"quantity\":\"dimensionless\"}],\"params\":[],\"sampleTimeS\":0}"
              }
            ],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-native-check-dynamic-lower/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:native-check-dynamic-range",
      "type": "Block",
      "label": "Dynamic range check",
      "properties": {
        "id": "native-check-dynamic-range",
        "name": "Dynamic range check",
        "kind": "studio",
        "summary": "Reports whether a scalar lies between two input bounds. Reversed bounds are invalid.",
        "behavior": "pass = (connected lower ≤ value ≤ connected upper).",
        "ports": [
          {
            "name": "in0",
            "direction": "input",
            "unit": "1",
            "description": "Value; real scalar.",
            "shape": [],
            "elementType": "real"
          },
          {
            "name": "in1",
            "direction": "input",
            "unit": "1",
            "description": "Lower bound; real scalar.",
            "shape": [],
            "elementType": "real"
          },
          {
            "name": "in2",
            "direction": "input",
            "unit": "1",
            "description": "Upper bound; real scalar.",
            "shape": [],
            "elementType": "real"
          },
          {
            "name": "out0",
            "direction": "output",
            "unit": "1",
            "description": "Within bounds; bool scalar.",
            "shape": [],
            "elementType": "bool"
          }
        ],
        "parameters": [],
        "equations": [
          "pass = (connected lower ≤ value ≤ connected upper)"
        ],
        "example": {
          "title": "Dynamic range check — worked example",
          "text": "Value = 7; Lower bound = 0; Upper bound = 10. Within bounds at 0 s = 1.",
          "url": "https://design.lemonergy.com/cosim.html?example=block-native-check-dynamic-range",
          "label": "Open Studio example",
          "inputs": [
            {
              "port": "in0",
              "label": "Value",
              "value": 7,
              "unit": "1"
            },
            {
              "port": "in1",
              "label": "Lower bound",
              "value": 0,
              "unit": "1"
            },
            {
              "port": "in2",
              "label": "Upper bound",
              "value": 10,
              "unit": "1"
            }
          ],
          "checks": [
            {
              "port": "out0",
              "label": "Within bounds",
              "atS": 0,
              "value": 1,
              "unit": "1",
              "tolerance": 1e-09
            }
          ]
        },
        "limits": [
          "Scalar real inputs with identical quantities; reversed bounds stop the run."
        ],
        "references": [],
        "referenceNote": "This software operation is defined by its public contract and worked example; no external research result is claimed.",
        "caseIds": [
          "native-native-check-dynamic-range"
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "exampleTraces": [
          {
            "id": "native-check-dynamic-range",
            "url": "https://lemonergy.com/learn/glossary/api/traces/native-check-dynamic-range.json?v=7c02fb14c9ac",
            "title": "Dynamic range check recorded example",
            "exampleId": "block-native-check-dynamic-range",
            "source": "Executed synthetic Lemonergy Studio example",
            "recordedOn": "2026-10-28",
            "points": 2,
            "channels": 1,
            "omittedChannels": 0,
            "interpolation": "linear",
            "solver": {
              "method": "dormand-prince-45",
              "reason": "no-continuous-states"
            }
          }
        ],
        "type": "native-check-dynamic-range",
        "implementationId": "native-check-dynamic-range",
        "url": "https://lemonergy.com/learn/glossary/blocks/native-check-dynamic-range/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/native-check-dynamic-range/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=block-native-check-dynamic-range"
          ]
        },
        "studioHelp": {
          "type": "native-check-dynamic-range",
          "namespace": "signal",
          "slug": "signal-block-native-check-dynamic-range",
          "canonicalSlug": "native-check-dynamic-range",
          "existing": true,
          "dynamic": false,
          "scene": {
            "title": "Dynamic range check",
            "label": "Dynamic range check",
            "summary": "Reports whether a scalar lies between two input bounds. Reversed bounds are invalid.",
            "details": [
              "Block type: native-check-dynamic-range.",
              "3 declared inputs and 1 declared output in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "input → condition → result",
              "label": "Dynamic range check",
              "caption": "Reports whether a scalar lies between two input bounds. Reversed bounds are invalid."
            },
            "inputs": [
              {
                "label": "Value",
                "shape": [],
                "elementType": "real",
                "quantity": "dimensionless",
                "id": "in0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              },
              {
                "label": "Lower bound",
                "shape": [],
                "elementType": "real",
                "quantity": "dimensionless",
                "id": "in1",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              },
              {
                "label": "Upper bound",
                "shape": [],
                "elementType": "real",
                "quantity": "dimensionless",
                "id": "in2",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              }
            ],
            "outputs": [
              {
                "label": "Within bounds",
                "shape": [],
                "elementType": "bool",
                "quantity": "dimensionless",
                "id": "out0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "bool"
              }
            ],
            "parameters": [
              {
                "id": "config",
                "label": "Configuration",
                "unit": "",
                "value": "{\"inputs\":[{\"label\":\"Value\",\"shape\":[],\"elementType\":\"real\",\"quantity\":\"dimensionless\"},{\"label\":\"Lower bound\",\"shape\":[],\"elementType\":\"real\",\"quantity\":\"dimensionless\"},{\"label\":\"Upper bound\",\"shape\":[],\"elementType\":\"real\",\"quantity\":\"dimensionless\"}],\"outputs\":[{\"label\":\"Within bounds\",\"shape\":[],\"elementType\":\"bool\",\"quantity\":\"dimensionless\"}],\"params\":[],\"sampleTimeS\":0}"
              }
            ],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-native-check-dynamic-range/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:native-check-dynamic-upper",
      "type": "Block",
      "label": "Dynamic upper-bound check",
      "properties": {
        "id": "native-check-dynamic-upper",
        "name": "Dynamic upper-bound check",
        "kind": "studio",
        "summary": "Checks a scalar against a connected inclusive upper bound.",
        "behavior": "pass = (value ≤ connected upper).",
        "ports": [
          {
            "name": "in0",
            "direction": "input",
            "unit": "1",
            "description": "Value; real scalar.",
            "shape": [],
            "elementType": "real"
          },
          {
            "name": "in1",
            "direction": "input",
            "unit": "1",
            "description": "Upper bound; real scalar.",
            "shape": [],
            "elementType": "real"
          },
          {
            "name": "out0",
            "direction": "output",
            "unit": "1",
            "description": "Pass; bool scalar.",
            "shape": [],
            "elementType": "bool"
          }
        ],
        "parameters": [],
        "equations": [
          "pass = (value ≤ connected upper)"
        ],
        "example": {
          "title": "Dynamic upper-bound check — worked example",
          "text": "Value = 2; Upper bound = 3. Pass at 0 s = 1.",
          "url": "https://design.lemonergy.com/cosim.html?example=block-native-check-dynamic-upper",
          "label": "Open Studio example",
          "inputs": [
            {
              "port": "in0",
              "label": "Value",
              "value": 2,
              "unit": "1"
            },
            {
              "port": "in1",
              "label": "Upper bound",
              "value": 3,
              "unit": "1"
            }
          ],
          "checks": [
            {
              "port": "out0",
              "label": "Pass",
              "atS": 0,
              "value": 1,
              "unit": "1",
              "tolerance": 1e-09
            }
          ]
        },
        "limits": [
          "Scalar real inputs with the same quantity; equality passes."
        ],
        "references": [],
        "referenceNote": "This software operation is defined by its public contract and worked example; no external research result is claimed.",
        "caseIds": [
          "native-native-check-dynamic-upper"
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "exampleTraces": [
          {
            "id": "native-check-dynamic-upper",
            "url": "https://lemonergy.com/learn/glossary/api/traces/native-check-dynamic-upper.json?v=bddb7a3f2812",
            "title": "Dynamic upper-bound check recorded example",
            "exampleId": "block-native-check-dynamic-upper",
            "source": "Executed synthetic Lemonergy Studio example",
            "recordedOn": "2026-10-28",
            "points": 2,
            "channels": 1,
            "omittedChannels": 0,
            "interpolation": "linear",
            "solver": {
              "method": "dormand-prince-45",
              "reason": "no-continuous-states"
            }
          }
        ],
        "type": "native-check-dynamic-upper",
        "implementationId": "native-check-dynamic-upper",
        "url": "https://lemonergy.com/learn/glossary/blocks/native-check-dynamic-upper/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/native-check-dynamic-upper/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=block-native-check-dynamic-upper"
          ]
        },
        "studioHelp": {
          "type": "native-check-dynamic-upper",
          "namespace": "signal",
          "slug": "signal-block-native-check-dynamic-upper",
          "canonicalSlug": "native-check-dynamic-upper",
          "existing": true,
          "dynamic": false,
          "scene": {
            "title": "Dynamic upper-bound check",
            "label": "Dynamic upper-bound check",
            "summary": "Checks a scalar against a connected inclusive upper bound.",
            "details": [
              "Block type: native-check-dynamic-upper.",
              "2 declared inputs and 1 declared output in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "input → condition → result",
              "label": "Dynamic upper-bound check",
              "caption": "Checks a scalar against a connected inclusive upper bound."
            },
            "inputs": [
              {
                "label": "Value",
                "shape": [],
                "elementType": "real",
                "quantity": "dimensionless",
                "id": "in0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              },
              {
                "label": "Upper bound",
                "shape": [],
                "elementType": "real",
                "quantity": "dimensionless",
                "id": "in1",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              }
            ],
            "outputs": [
              {
                "label": "Pass",
                "shape": [],
                "elementType": "bool",
                "quantity": "dimensionless",
                "id": "out0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "bool"
              }
            ],
            "parameters": [
              {
                "id": "config",
                "label": "Configuration",
                "unit": "",
                "value": "{\"inputs\":[{\"label\":\"Value\",\"shape\":[],\"elementType\":\"real\",\"quantity\":\"dimensionless\"},{\"label\":\"Upper bound\",\"shape\":[],\"elementType\":\"real\",\"quantity\":\"dimensionless\"}],\"outputs\":[{\"label\":\"Pass\",\"shape\":[],\"elementType\":\"bool\",\"quantity\":\"dimensionless\"}],\"params\":[],\"sampleTimeS\":0}"
              }
            ],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-native-check-dynamic-upper/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:native-check-gap",
      "type": "Block",
      "label": "Signal gap check",
      "properties": {
        "id": "native-check-gap",
        "name": "Signal gap check",
        "kind": "studio",
        "summary": "Reports whether the absolute difference between two inputs is within a configured tolerance.",
        "behavior": "pass = (|first − second| ≤ tolerance).",
        "ports": [
          {
            "name": "in0",
            "direction": "input",
            "unit": "1",
            "description": "First value; real scalar.",
            "shape": [],
            "elementType": "real"
          },
          {
            "name": "in1",
            "direction": "input",
            "unit": "1",
            "description": "Second value; real scalar.",
            "shape": [],
            "elementType": "real"
          },
          {
            "name": "out0",
            "direction": "output",
            "unit": "1",
            "description": "Pass; bool scalar.",
            "shape": [],
            "elementType": "bool"
          }
        ],
        "parameters": [
          {
            "key": "params[0]",
            "label": "Maximum absolute difference",
            "unit": "1",
            "default": 0.5,
            "description": "Configured value for Maximum absolute difference."
          }
        ],
        "equations": [
          "pass = (|first − second| ≤ tolerance)"
        ],
        "example": {
          "title": "Signal gap check — worked example",
          "text": "First value = 2; Second value = 2.4. Pass at 0 s = 1.",
          "url": "https://design.lemonergy.com/cosim.html?example=block-native-check-gap",
          "label": "Open Studio example",
          "inputs": [
            {
              "port": "in0",
              "label": "First value",
              "value": 2,
              "unit": "1"
            },
            {
              "port": "in1",
              "label": "Second value",
              "value": 2.4,
              "unit": "1"
            }
          ],
          "checks": [
            {
              "port": "out0",
              "label": "Pass",
              "atS": 0,
              "value": 1,
              "unit": "1",
              "tolerance": 1e-09
            }
          ]
        },
        "limits": [
          "Scalar real inputs with equal quantities; this is an absolute difference check."
        ],
        "references": [],
        "referenceNote": "This software operation is defined by its public contract and worked example; no external research result is claimed.",
        "caseIds": [
          "native-native-check-gap"
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "exampleTraces": [
          {
            "id": "native-check-gap",
            "url": "https://lemonergy.com/learn/glossary/api/traces/native-check-gap.json?v=2edf6afa7ca5",
            "title": "Signal gap check recorded example",
            "exampleId": "block-native-check-gap",
            "source": "Executed synthetic Lemonergy Studio example",
            "recordedOn": "2026-10-28",
            "points": 2,
            "channels": 1,
            "omittedChannels": 0,
            "interpolation": "linear",
            "solver": {
              "method": "dormand-prince-45",
              "reason": "no-continuous-states"
            }
          }
        ],
        "type": "native-check-gap",
        "implementationId": "native-check-gap",
        "url": "https://lemonergy.com/learn/glossary/blocks/native-check-gap/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/native-check-gap/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=block-native-check-gap"
          ]
        },
        "studioHelp": {
          "type": "native-check-gap",
          "namespace": "signal",
          "slug": "signal-block-native-check-gap",
          "canonicalSlug": "native-check-gap",
          "existing": true,
          "dynamic": false,
          "scene": {
            "title": "Signal gap check",
            "label": "Signal gap check",
            "summary": "Reports whether the absolute difference between two inputs is within a configured tolerance.",
            "details": [
              "Block type: native-check-gap.",
              "2 declared inputs and 1 declared output in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "input → condition → result",
              "label": "Signal gap check",
              "caption": "Reports whether the absolute difference between two inputs is within a configured tolerance."
            },
            "inputs": [
              {
                "label": "First value",
                "shape": [],
                "elementType": "real",
                "quantity": "dimensionless",
                "id": "in0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              },
              {
                "label": "Second value",
                "shape": [],
                "elementType": "real",
                "quantity": "dimensionless",
                "id": "in1",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              }
            ],
            "outputs": [
              {
                "label": "Pass",
                "shape": [],
                "elementType": "bool",
                "quantity": "dimensionless",
                "id": "out0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "bool"
              }
            ],
            "parameters": [
              {
                "id": "config",
                "label": "Configuration",
                "unit": "",
                "value": "{\"inputs\":[{\"label\":\"First value\",\"shape\":[],\"elementType\":\"real\",\"quantity\":\"dimensionless\"},{\"label\":\"Second value\",\"shape\":[],\"elementType\":\"real\",\"quantity\":\"dimensionless\"}],\"outputs\":[{\"label\":\"Pass\",\"shape\":[],\"elementType\":\"bool\",\"quantity\":\"dimensionless\"}],\"params\":[0.5],\"sampleTimeS\":0}"
              }
            ],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-native-check-gap/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:native-check-gradient",
      "type": "Block",
      "label": "Sample difference check",
      "properties": {
        "id": "native-check-gradient",
        "name": "Sample difference check",
        "kind": "studio",
        "summary": "Checks absolute per-sample change against a strict maximum. The first comparison is skipped and reports zero change.",
        "behavior": "difference[0] = 0; difference[k] = |value[k] − value[k−1]|. pass = (difference < configured maximum).",
        "ports": [
          {
            "name": "in0",
            "direction": "input",
            "unit": "1",
            "description": "Value; real scalar.",
            "shape": [],
            "elementType": "real"
          },
          {
            "name": "out0",
            "direction": "output",
            "unit": "1",
            "description": "Pass; bool scalar.",
            "shape": [],
            "elementType": "bool"
          },
          {
            "name": "out1",
            "direction": "output",
            "unit": "1",
            "description": "Absolute sample difference; real scalar.",
            "shape": [],
            "elementType": "real"
          }
        ],
        "parameters": [
          {
            "key": "sampleTimeS",
            "label": "Sample period",
            "unit": "s",
            "default": 0.1,
            "min": 0,
            "description": "Positive interval between sample instants. Values are held between samples."
          },
          {
            "key": "params[0]",
            "label": "Maximum absolute sample difference",
            "unit": "1",
            "default": 0.3,
            "description": "Configured value for Maximum absolute sample difference."
          }
        ],
        "equations": [
          "difference[0] = 0; difference[k] = |value[k] − value[k−1]|",
          "pass = (difference < configured maximum)"
        ],
        "example": {
          "title": "Sample difference check — worked example",
          "text": "Value = 1. Pass at 0 s = 1; Absolute sample difference at 0 s = 0.",
          "url": "https://design.lemonergy.com/cosim.html?example=block-native-check-gradient",
          "label": "Open Studio example",
          "inputs": [
            {
              "port": "in0",
              "label": "Value",
              "value": 1,
              "unit": "1"
            }
          ],
          "checks": [
            {
              "port": "out0",
              "label": "Pass",
              "atS": 0,
              "value": 1,
              "unit": "1",
              "tolerance": 1e-09
            },
            {
              "port": "out1",
              "label": "Absolute sample difference",
              "atS": 0,
              "value": 0,
              "unit": "1",
              "tolerance": 1e-09
            }
          ]
        },
        "limits": [
          "Checks change per sample, not change divided by elapsed time; the first comparison is skipped."
        ],
        "references": [],
        "referenceNote": "This software operation is defined by its public contract and worked example; no external research result is claimed.",
        "caseIds": [
          "native-native-check-gradient"
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "exampleTraces": [
          {
            "id": "native-check-gradient",
            "url": "https://lemonergy.com/learn/glossary/api/traces/native-check-gradient.json?v=ce70ae5b0637",
            "title": "Sample difference check recorded example",
            "exampleId": "block-native-check-gradient",
            "source": "Executed synthetic Lemonergy Studio example",
            "recordedOn": "2026-10-28",
            "points": 11,
            "channels": 2,
            "omittedChannels": 0,
            "interpolation": "step",
            "solver": {
              "method": "dormand-prince-45",
              "reason": "no-continuous-states"
            }
          }
        ],
        "type": "native-check-gradient",
        "implementationId": "native-check-gradient",
        "url": "https://lemonergy.com/learn/glossary/blocks/native-check-gradient/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/native-check-gradient/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=block-native-check-gradient"
          ]
        },
        "studioHelp": {
          "type": "native-check-gradient",
          "namespace": "signal",
          "slug": "signal-block-native-check-gradient",
          "canonicalSlug": "native-check-gradient",
          "existing": true,
          "dynamic": false,
          "scene": {
            "title": "Sample difference check",
            "label": "Sample difference check",
            "summary": "Checks absolute per-sample change against a strict maximum. The first comparison is skipped and reports zero change.",
            "details": [
              "Block type: native-check-gradient.",
              "1 declared input and 2 declared outputs in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "input → condition → result",
              "label": "Sample difference check",
              "caption": "Checks absolute per-sample change against a strict maximum. The first comparison is skipped and reports zero change."
            },
            "inputs": [
              {
                "label": "Value",
                "shape": [],
                "elementType": "real",
                "quantity": "dimensionless",
                "id": "in0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              }
            ],
            "outputs": [
              {
                "label": "Pass",
                "shape": [],
                "elementType": "bool",
                "quantity": "dimensionless",
                "id": "out0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "bool"
              },
              {
                "label": "Absolute sample difference",
                "shape": [],
                "elementType": "real",
                "quantity": "dimensionless",
                "id": "out1",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              }
            ],
            "parameters": [
              {
                "id": "config",
                "label": "Configuration",
                "unit": "",
                "value": "{\"inputs\":[{\"label\":\"Value\",\"shape\":[],\"elementType\":\"real\",\"quantity\":\"dimensionless\"}],\"outputs\":[{\"label\":\"Pass\",\"shape\":[],\"elementType\":\"bool\",\"quantity\":\"dimensionless\"},{\"label\":\"Absolute sample difference\",\"shape\":[],\"elementType\":\"real\",\"quantity\":\"dimensionless\"}],\"params\":[0.3],\"sampleTimeS\":0.1}"
              }
            ],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-native-check-gradient/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:native-check-lower",
      "type": "Block",
      "label": "Static lower-bound check",
      "properties": {
        "id": "native-check-lower",
        "name": "Static lower-bound check",
        "kind": "studio",
        "summary": "Reports whether a scalar is greater than or equal to its configured bound.",
        "behavior": "pass = (value ≥ lower).",
        "ports": [
          {
            "name": "in0",
            "direction": "input",
            "unit": "1",
            "description": "Value; real scalar.",
            "shape": [],
            "elementType": "real"
          },
          {
            "name": "out0",
            "direction": "output",
            "unit": "1",
            "description": "Pass; bool scalar.",
            "shape": [],
            "elementType": "bool"
          }
        ],
        "parameters": [
          {
            "key": "params[0]",
            "label": "Lower bound",
            "unit": "1",
            "default": 3,
            "description": "Configured value for Lower bound."
          }
        ],
        "equations": [
          "pass = (value ≥ lower)"
        ],
        "example": {
          "title": "Static lower-bound check — worked example",
          "text": "Value = 2. Pass at 0 s = 0.",
          "url": "https://design.lemonergy.com/cosim.html?example=block-native-check-lower",
          "label": "Open Studio example",
          "inputs": [
            {
              "port": "in0",
              "label": "Value",
              "value": 2,
              "unit": "1"
            }
          ],
          "checks": [
            {
              "port": "out0",
              "label": "Pass",
              "atS": 0,
              "value": 0,
              "unit": "1",
              "tolerance": 1e-09
            }
          ]
        },
        "limits": [
          "Scalar real input; equality with the lower bound passes."
        ],
        "references": [],
        "referenceNote": "This software operation is defined by its public contract and worked example; no external research result is claimed.",
        "caseIds": [
          "native-native-check-lower"
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "exampleTraces": [
          {
            "id": "native-check-lower",
            "url": "https://lemonergy.com/learn/glossary/api/traces/native-check-lower.json?v=95c058911f8c",
            "title": "Static lower-bound check recorded example",
            "exampleId": "block-native-check-lower",
            "source": "Executed synthetic Lemonergy Studio example",
            "recordedOn": "2026-10-28",
            "points": 2,
            "channels": 1,
            "omittedChannels": 0,
            "interpolation": "linear",
            "solver": {
              "method": "dormand-prince-45",
              "reason": "no-continuous-states"
            }
          }
        ],
        "type": "native-check-lower",
        "implementationId": "native-check-lower",
        "url": "https://lemonergy.com/learn/glossary/blocks/native-check-lower/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/native-check-lower/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=block-native-check-lower"
          ]
        },
        "studioHelp": {
          "type": "native-check-lower",
          "namespace": "signal",
          "slug": "signal-block-native-check-lower",
          "canonicalSlug": "native-check-lower",
          "existing": true,
          "dynamic": false,
          "scene": {
            "title": "Static lower-bound check",
            "label": "Static lower-bound check",
            "summary": "Reports whether a scalar is greater than or equal to its configured bound.",
            "details": [
              "Block type: native-check-lower.",
              "1 declared input and 1 declared output in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "input → condition → result",
              "label": "Static lower-bound check",
              "caption": "Reports whether a scalar is greater than or equal to its configured bound."
            },
            "inputs": [
              {
                "label": "Value",
                "shape": [],
                "elementType": "real",
                "quantity": "dimensionless",
                "id": "in0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              }
            ],
            "outputs": [
              {
                "label": "Pass",
                "shape": [],
                "elementType": "bool",
                "quantity": "dimensionless",
                "id": "out0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "bool"
              }
            ],
            "parameters": [
              {
                "id": "config",
                "label": "Configuration",
                "unit": "",
                "value": "{\"inputs\":[{\"label\":\"Value\",\"shape\":[],\"elementType\":\"real\",\"quantity\":\"dimensionless\"}],\"outputs\":[{\"label\":\"Pass\",\"shape\":[],\"elementType\":\"bool\",\"quantity\":\"dimensionless\"}],\"params\":[3],\"sampleTimeS\":0}"
              }
            ],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-native-check-lower/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:native-check-range",
      "type": "Block",
      "label": "Static range check",
      "properties": {
        "id": "native-check-range",
        "name": "Static range check",
        "kind": "studio",
        "summary": "Reports whether a scalar lies inside inclusive configured bounds.",
        "behavior": "pass = (lower ≤ value ≤ upper).",
        "ports": [
          {
            "name": "in0",
            "direction": "input",
            "unit": "1",
            "description": "Value; real scalar.",
            "shape": [],
            "elementType": "real"
          },
          {
            "name": "out0",
            "direction": "output",
            "unit": "1",
            "description": "Within bounds; bool scalar.",
            "shape": [],
            "elementType": "bool"
          }
        ],
        "parameters": [
          {
            "key": "params[0]",
            "label": "Lower bound",
            "unit": "1",
            "default": 0,
            "description": "Configured value for Lower bound."
          },
          {
            "key": "params[1]",
            "label": "Upper bound",
            "unit": "1",
            "default": 10,
            "description": "Configured value for Upper bound."
          }
        ],
        "equations": [
          "pass = (lower ≤ value ≤ upper)"
        ],
        "example": {
          "title": "Static range check — worked example",
          "text": "Value = 7. Within bounds at 0 s = 1.",
          "url": "https://design.lemonergy.com/cosim.html?example=block-native-check-range",
          "label": "Open Studio example",
          "inputs": [
            {
              "port": "in0",
              "label": "Value",
              "value": 7,
              "unit": "1"
            }
          ],
          "checks": [
            {
              "port": "out0",
              "label": "Within bounds",
              "atS": 0,
              "value": 1,
              "unit": "1",
              "tolerance": 1e-09
            }
          ]
        },
        "limits": [
          "Scalar real input and inclusive configured bounds."
        ],
        "references": [],
        "referenceNote": "This software operation is defined by its public contract and worked example; no external research result is claimed.",
        "caseIds": [
          "native-native-check-range"
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "exampleTraces": [
          {
            "id": "native-check-range",
            "url": "https://lemonergy.com/learn/glossary/api/traces/native-check-range.json?v=f02af8419032",
            "title": "Static range check recorded example",
            "exampleId": "block-native-check-range",
            "source": "Executed synthetic Lemonergy Studio example",
            "recordedOn": "2026-10-28",
            "points": 2,
            "channels": 1,
            "omittedChannels": 0,
            "interpolation": "linear",
            "solver": {
              "method": "dormand-prince-45",
              "reason": "no-continuous-states"
            }
          }
        ],
        "type": "native-check-range",
        "implementationId": "native-check-range",
        "url": "https://lemonergy.com/learn/glossary/blocks/native-check-range/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/native-check-range/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=block-native-check-range"
          ]
        },
        "studioHelp": {
          "type": "native-check-range",
          "namespace": "signal",
          "slug": "signal-block-native-check-range",
          "canonicalSlug": "native-check-range",
          "existing": true,
          "dynamic": false,
          "scene": {
            "title": "Static range check",
            "label": "Static range check",
            "summary": "Reports whether a scalar lies inside inclusive configured bounds.",
            "details": [
              "Block type: native-check-range.",
              "1 declared input and 1 declared output in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "input → condition → result",
              "label": "Static range check",
              "caption": "Reports whether a scalar lies inside inclusive configured bounds."
            },
            "inputs": [
              {
                "label": "Value",
                "shape": [],
                "elementType": "real",
                "quantity": "dimensionless",
                "id": "in0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              }
            ],
            "outputs": [
              {
                "label": "Within bounds",
                "shape": [],
                "elementType": "bool",
                "quantity": "dimensionless",
                "id": "out0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "bool"
              }
            ],
            "parameters": [
              {
                "id": "config",
                "label": "Configuration",
                "unit": "",
                "value": "{\"inputs\":[{\"label\":\"Value\",\"shape\":[],\"elementType\":\"real\",\"quantity\":\"dimensionless\"}],\"outputs\":[{\"label\":\"Within bounds\",\"shape\":[],\"elementType\":\"bool\",\"quantity\":\"dimensionless\"}],\"params\":[0,10],\"sampleTimeS\":0}"
              }
            ],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-native-check-range/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:native-check-resolution",
      "type": "Block",
      "label": "Input resolution check",
      "properties": {
        "id": "native-check-resolution",
        "name": "Input resolution check",
        "kind": "studio",
        "summary": "Checks distance to the nearest quantization grid point with an explicit absolute tolerance.",
        "behavior": "pass = (|value − spacing × round(value/spacing)| ≤ tolerance).",
        "ports": [
          {
            "name": "in0",
            "direction": "input",
            "unit": "1",
            "description": "Value; real scalar.",
            "shape": [],
            "elementType": "real"
          },
          {
            "name": "out0",
            "direction": "output",
            "unit": "1",
            "description": "On grid; bool scalar.",
            "shape": [],
            "elementType": "bool"
          }
        ],
        "parameters": [
          {
            "key": "params[0]",
            "label": "Grid spacing",
            "unit": "1",
            "default": 0.25,
            "description": "Configured value for Grid spacing."
          },
          {
            "key": "params[1]",
            "label": "Absolute tolerance",
            "unit": "1",
            "default": 1e-09,
            "description": "Configured value for Absolute tolerance."
          }
        ],
        "equations": [
          "pass = (|value − spacing × round(value/spacing)| ≤ tolerance)"
        ],
        "example": {
          "title": "Input resolution check — worked example",
          "text": "Value = 1.5. On grid at 0 s = 1.",
          "url": "https://design.lemonergy.com/cosim.html?example=block-native-check-resolution",
          "label": "Open Studio example",
          "inputs": [
            {
              "port": "in0",
              "label": "Value",
              "value": 1.5,
              "unit": "1"
            }
          ],
          "checks": [
            {
              "port": "out0",
              "label": "On grid",
              "atS": 0,
              "value": 1,
              "unit": "1",
              "tolerance": 1e-09
            }
          ]
        },
        "limits": [
          "Positive grid spacing and absolute tolerance smaller than half the spacing are required."
        ],
        "references": [],
        "referenceNote": "This software operation is defined by its public contract and worked example; no external research result is claimed.",
        "caseIds": [
          "native-native-check-resolution"
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "exampleTraces": [
          {
            "id": "native-check-resolution",
            "url": "https://lemonergy.com/learn/glossary/api/traces/native-check-resolution.json?v=1106a0eb5f2d",
            "title": "Input resolution check recorded example",
            "exampleId": "block-native-check-resolution",
            "source": "Executed synthetic Lemonergy Studio example",
            "recordedOn": "2026-10-28",
            "points": 2,
            "channels": 1,
            "omittedChannels": 0,
            "interpolation": "linear",
            "solver": {
              "method": "dormand-prince-45",
              "reason": "no-continuous-states"
            }
          }
        ],
        "type": "native-check-resolution",
        "implementationId": "native-check-resolution",
        "url": "https://lemonergy.com/learn/glossary/blocks/native-check-resolution/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/native-check-resolution/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=block-native-check-resolution"
          ]
        },
        "studioHelp": {
          "type": "native-check-resolution",
          "namespace": "signal",
          "slug": "signal-block-native-check-resolution",
          "canonicalSlug": "native-check-resolution",
          "existing": true,
          "dynamic": false,
          "scene": {
            "title": "Input resolution check",
            "label": "Input resolution check",
            "summary": "Checks distance to the nearest quantization grid point with an explicit absolute tolerance.",
            "details": [
              "Block type: native-check-resolution.",
              "1 declared input and 1 declared output in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "input → condition → result",
              "label": "Input resolution check",
              "caption": "Checks distance to the nearest quantization grid point with an explicit absolute tolerance."
            },
            "inputs": [
              {
                "label": "Value",
                "shape": [],
                "elementType": "real",
                "quantity": "dimensionless",
                "id": "in0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              }
            ],
            "outputs": [
              {
                "label": "On grid",
                "shape": [],
                "elementType": "bool",
                "quantity": "dimensionless",
                "id": "out0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "bool"
              }
            ],
            "parameters": [
              {
                "id": "config",
                "label": "Configuration",
                "unit": "",
                "value": "{\"inputs\":[{\"label\":\"Value\",\"shape\":[],\"elementType\":\"real\",\"quantity\":\"dimensionless\"}],\"outputs\":[{\"label\":\"On grid\",\"shape\":[],\"elementType\":\"bool\",\"quantity\":\"dimensionless\"}],\"params\":[0.25,1e-9],\"sampleTimeS\":0}"
              }
            ],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-native-check-resolution/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:native-check-static-gap",
      "type": "Block",
      "label": "Forbidden interval check",
      "properties": {
        "id": "native-check-static-gap",
        "name": "Forbidden interval check",
        "kind": "studio",
        "summary": "Passes only values outside the closed forbidden interval; values equal to either boundary fail.",
        "behavior": "pass = (value < lower OR value > upper).",
        "ports": [
          {
            "name": "in0",
            "direction": "input",
            "unit": "1",
            "description": "Value; real scalar.",
            "shape": [],
            "elementType": "real"
          },
          {
            "name": "out0",
            "direction": "output",
            "unit": "1",
            "description": "Outside forbidden interval; bool scalar.",
            "shape": [],
            "elementType": "bool"
          }
        ],
        "parameters": [
          {
            "key": "params[0]",
            "label": "Forbidden interval lower bound",
            "unit": "1",
            "default": 2,
            "description": "Configured value for Forbidden interval lower bound."
          },
          {
            "key": "params[1]",
            "label": "Forbidden interval upper bound",
            "unit": "1",
            "default": 4,
            "description": "Configured value for Forbidden interval upper bound."
          }
        ],
        "equations": [
          "pass = (value < lower OR value > upper)"
        ],
        "example": {
          "title": "Forbidden interval check — worked example",
          "text": "Value = 3. Outside forbidden interval at 0 s = 0.",
          "url": "https://design.lemonergy.com/cosim.html?example=block-native-check-static-gap",
          "label": "Open Studio example",
          "inputs": [
            {
              "port": "in0",
              "label": "Value",
              "value": 3,
              "unit": "1"
            }
          ],
          "checks": [
            {
              "port": "out0",
              "label": "Outside forbidden interval",
              "atS": 0,
              "value": 0,
              "unit": "1",
              "tolerance": 1e-09
            }
          ]
        },
        "limits": [
          "Values exactly on either forbidden boundary fail."
        ],
        "references": [],
        "referenceNote": "This software operation is defined by its public contract and worked example; no external research result is claimed.",
        "caseIds": [
          "native-native-check-static-gap"
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "exampleTraces": [
          {
            "id": "native-check-static-gap",
            "url": "https://lemonergy.com/learn/glossary/api/traces/native-check-static-gap.json?v=baddd51e6b3e",
            "title": "Forbidden interval check recorded example",
            "exampleId": "block-native-check-static-gap",
            "source": "Executed synthetic Lemonergy Studio example",
            "recordedOn": "2026-10-28",
            "points": 2,
            "channels": 1,
            "omittedChannels": 0,
            "interpolation": "linear",
            "solver": {
              "method": "dormand-prince-45",
              "reason": "no-continuous-states"
            }
          }
        ],
        "type": "native-check-static-gap",
        "implementationId": "native-check-static-gap",
        "url": "https://lemonergy.com/learn/glossary/blocks/native-check-static-gap/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/native-check-static-gap/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=block-native-check-static-gap"
          ]
        },
        "studioHelp": {
          "type": "native-check-static-gap",
          "namespace": "signal",
          "slug": "signal-block-native-check-static-gap",
          "canonicalSlug": "native-check-static-gap",
          "existing": true,
          "dynamic": false,
          "scene": {
            "title": "Forbidden interval check",
            "label": "Forbidden interval check",
            "summary": "Passes only values outside the closed forbidden interval; values equal to either boundary fail.",
            "details": [
              "Block type: native-check-static-gap.",
              "1 declared input and 1 declared output in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "input → condition → result",
              "label": "Forbidden interval check",
              "caption": "Passes only values outside the closed forbidden interval; values equal to either boundary fail."
            },
            "inputs": [
              {
                "label": "Value",
                "shape": [],
                "elementType": "real",
                "quantity": "dimensionless",
                "id": "in0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              }
            ],
            "outputs": [
              {
                "label": "Outside forbidden interval",
                "shape": [],
                "elementType": "bool",
                "quantity": "dimensionless",
                "id": "out0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "bool"
              }
            ],
            "parameters": [
              {
                "id": "config",
                "label": "Configuration",
                "unit": "",
                "value": "{\"inputs\":[{\"label\":\"Value\",\"shape\":[],\"elementType\":\"real\",\"quantity\":\"dimensionless\"}],\"outputs\":[{\"label\":\"Outside forbidden interval\",\"shape\":[],\"elementType\":\"bool\",\"quantity\":\"dimensionless\"}],\"params\":[2,4],\"sampleTimeS\":0}"
              }
            ],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-native-check-static-gap/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:native-check-upper",
      "type": "Block",
      "label": "Static upper-bound check",
      "properties": {
        "id": "native-check-upper",
        "name": "Static upper-bound check",
        "kind": "studio",
        "summary": "Reports whether a scalar is less than or equal to its configured bound.",
        "behavior": "pass = (value ≤ upper).",
        "ports": [
          {
            "name": "in0",
            "direction": "input",
            "unit": "1",
            "description": "Value; real scalar.",
            "shape": [],
            "elementType": "real"
          },
          {
            "name": "out0",
            "direction": "output",
            "unit": "1",
            "description": "Pass; bool scalar.",
            "shape": [],
            "elementType": "bool"
          }
        ],
        "parameters": [
          {
            "key": "params[0]",
            "label": "Upper bound",
            "unit": "1",
            "default": 3,
            "description": "Configured value for Upper bound."
          }
        ],
        "equations": [
          "pass = (value ≤ upper)"
        ],
        "example": {
          "title": "Static upper-bound check — worked example",
          "text": "Value = 2. Pass at 0 s = 1.",
          "url": "https://design.lemonergy.com/cosim.html?example=block-native-check-upper",
          "label": "Open Studio example",
          "inputs": [
            {
              "port": "in0",
              "label": "Value",
              "value": 2,
              "unit": "1"
            }
          ],
          "checks": [
            {
              "port": "out0",
              "label": "Pass",
              "atS": 0,
              "value": 1,
              "unit": "1",
              "tolerance": 1e-09
            }
          ]
        },
        "limits": [
          "Scalar real input; equality with the upper bound passes."
        ],
        "references": [],
        "referenceNote": "This software operation is defined by its public contract and worked example; no external research result is claimed.",
        "caseIds": [
          "native-native-check-upper"
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "exampleTraces": [
          {
            "id": "native-check-upper",
            "url": "https://lemonergy.com/learn/glossary/api/traces/native-check-upper.json?v=301ec607020c",
            "title": "Static upper-bound check recorded example",
            "exampleId": "block-native-check-upper",
            "source": "Executed synthetic Lemonergy Studio example",
            "recordedOn": "2026-10-28",
            "points": 2,
            "channels": 1,
            "omittedChannels": 0,
            "interpolation": "linear",
            "solver": {
              "method": "dormand-prince-45",
              "reason": "no-continuous-states"
            }
          }
        ],
        "type": "native-check-upper",
        "implementationId": "native-check-upper",
        "url": "https://lemonergy.com/learn/glossary/blocks/native-check-upper/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/native-check-upper/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=block-native-check-upper"
          ]
        },
        "studioHelp": {
          "type": "native-check-upper",
          "namespace": "signal",
          "slug": "signal-block-native-check-upper",
          "canonicalSlug": "native-check-upper",
          "existing": true,
          "dynamic": false,
          "scene": {
            "title": "Static upper-bound check",
            "label": "Static upper-bound check",
            "summary": "Reports whether a scalar is less than or equal to its configured bound.",
            "details": [
              "Block type: native-check-upper.",
              "1 declared input and 1 declared output in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "input → condition → result",
              "label": "Static upper-bound check",
              "caption": "Reports whether a scalar is less than or equal to its configured bound."
            },
            "inputs": [
              {
                "label": "Value",
                "shape": [],
                "elementType": "real",
                "quantity": "dimensionless",
                "id": "in0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              }
            ],
            "outputs": [
              {
                "label": "Pass",
                "shape": [],
                "elementType": "bool",
                "quantity": "dimensionless",
                "id": "out0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "bool"
              }
            ],
            "parameters": [
              {
                "id": "config",
                "label": "Configuration",
                "unit": "",
                "value": "{\"inputs\":[{\"label\":\"Value\",\"shape\":[],\"elementType\":\"real\",\"quantity\":\"dimensionless\"}],\"outputs\":[{\"label\":\"Pass\",\"shape\":[],\"elementType\":\"bool\",\"quantity\":\"dimensionless\"}],\"params\":[3],\"sampleTimeS\":0}"
              }
            ],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-native-check-upper/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:native-compare-zero",
      "type": "Block",
      "label": "Compare to zero",
      "properties": {
        "id": "native-compare-zero",
        "name": "Compare to zero",
        "kind": "studio",
        "summary": "Compares each input value with zero.",
        "behavior": "y = (u comparison 0). The worked example connects this operation to signals in Lemonergy Studio.",
        "ports": [
          {
            "name": "in0",
            "direction": "input",
            "unit": "1",
            "description": "Value; real scalar.",
            "shape": [],
            "elementType": "real"
          },
          {
            "name": "out0",
            "direction": "output",
            "unit": "1",
            "description": "Result; bool scalar.",
            "shape": [],
            "elementType": "bool"
          }
        ],
        "parameters": [
          {
            "key": "params[0]",
            "label": "Comparison",
            "unit": "1",
            "default": 0,
            "description": "0 <; 1 ≤; 2 =; 3 ≠; 4 ≥; 5 >."
          }
        ],
        "equations": [
          "y = (u comparison 0)"
        ],
        "example": {
          "title": "Compare to zero — worked example",
          "text": "Value = -2. Result at 0 s = 1.",
          "url": "https://design.lemonergy.com/cosim.html?example=block-native-compare-zero",
          "label": "Open Studio example",
          "inputs": [
            {
              "port": "in0",
              "label": "Value",
              "value": -2,
              "unit": "1"
            }
          ],
          "checks": [
            {
              "port": "out0",
              "label": "Result",
              "atS": 0,
              "value": 1,
              "unit": "1",
              "tolerance": 1e-08
            }
          ]
        },
        "limits": [
          "Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed."
        ],
        "references": [],
        "referenceNote": "This software operation and its numerical conventions are defined by the public contract and worked example; no external research result is claimed.",
        "caseIds": [
          "native-native-compare-zero"
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "exampleTraces": [
          {
            "id": "native-compare-zero",
            "url": "https://lemonergy.com/learn/glossary/api/traces/native-compare-zero.json?v=293520851c87",
            "title": "Compare to zero recorded example",
            "exampleId": "block-native-compare-zero",
            "source": "Executed synthetic Lemonergy Studio example",
            "recordedOn": "2026-10-28",
            "points": 2,
            "channels": 1,
            "omittedChannels": 0,
            "interpolation": "linear",
            "solver": {
              "method": "dormand-prince-45",
              "reason": "no-continuous-states"
            }
          }
        ],
        "type": "native-compare-zero",
        "implementationId": "native-compare-zero",
        "url": "https://lemonergy.com/learn/glossary/blocks/native-compare-zero/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/native-compare-zero/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=block-native-compare-zero"
          ]
        },
        "studioHelp": {
          "type": "native-compare-zero",
          "namespace": "signal",
          "slug": "signal-block-native-compare-zero",
          "canonicalSlug": "native-compare-zero",
          "existing": true,
          "dynamic": false,
          "scene": {
            "title": "Compare to zero",
            "label": "Compare to zero",
            "summary": "Compares each input value with zero.",
            "details": [
              "Block type: native-compare-zero.",
              "1 declared input and 1 declared output in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "input → condition → result",
              "label": "Compare to zero",
              "caption": "Compares each input value with zero."
            },
            "inputs": [
              {
                "label": "Value",
                "shape": [],
                "quantity": "dimensionless",
                "elementType": "real",
                "id": "in0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              }
            ],
            "outputs": [
              {
                "label": "Result",
                "shape": [],
                "quantity": "dimensionless",
                "elementType": "bool",
                "id": "out0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "bool"
              }
            ],
            "parameters": [
              {
                "id": "config",
                "label": "Configuration",
                "unit": "",
                "value": "{\"inputs\":[{\"label\":\"Value\",\"shape\":[],\"quantity\":\"inherit\",\"elementType\":\"real\"}],\"outputs\":[{\"label\":\"Result\",\"shape\":[],\"quantity\":\"dimensionless\",\"elementType\":\"bool\"}],\"sampleTimeS\":0,\"params\":[0],\"tables\":[]}"
              }
            ],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-native-compare-zero/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:native-discrete-pid",
      "type": "Block",
      "label": "Discrete weighted PID",
      "properties": {
        "id": "native-discrete-pid",
        "name": "Discrete weighted PID",
        "kind": "studio",
        "summary": "Combines proportional, integral and filtered derivative control with setpoint weights and limits.",
        "behavior": "e = reference − measurement. I candidate = I previous + Ki × elapsed_time × e. u = clamp(Kp × (b reference − measurement) + I + filtered derivative, lower, upper). The worked example connects this operation to signals in Lemonergy Studio.",
        "ports": [
          {
            "name": "in0",
            "direction": "input",
            "unit": "1",
            "description": "Setpoint; real scalar.",
            "shape": [],
            "elementType": "real"
          },
          {
            "name": "in1",
            "direction": "input",
            "unit": "1",
            "description": "Measurement; real scalar.",
            "shape": [],
            "elementType": "real"
          },
          {
            "name": "out0",
            "direction": "output",
            "unit": "1",
            "description": "Control; real scalar.",
            "shape": [],
            "elementType": "real"
          }
        ],
        "parameters": [
          {
            "key": "sampleTimeS",
            "label": "Sample period",
            "unit": "s",
            "default": 0.1,
            "description": "Exact sample grid period. Elapsed-time integration begins after initialization.",
            "min": 1e-06
          },
          {
            "key": "params[0]",
            "label": "Proportional gain",
            "unit": "1",
            "default": 1,
            "description": "Configured finite numerical parameter."
          },
          {
            "key": "params[1]",
            "label": "Integral gain",
            "unit": "1",
            "default": 0.5,
            "description": "Configured finite numerical parameter."
          },
          {
            "key": "params[2]",
            "label": "Derivative gain",
            "unit": "1",
            "default": 0,
            "description": "Configured finite numerical parameter."
          },
          {
            "key": "params[3]",
            "label": "Derivative filter time",
            "unit": "s",
            "default": 0.1,
            "description": "Configured finite numerical parameter."
          },
          {
            "key": "params[4]",
            "label": "Lower output limit",
            "unit": "1",
            "default": -10,
            "description": "Configured finite numerical parameter."
          },
          {
            "key": "params[5]",
            "label": "Upper output limit",
            "unit": "1",
            "default": 10,
            "description": "Configured finite numerical parameter."
          },
          {
            "key": "params[6]",
            "label": "Proportional setpoint weight",
            "unit": "1",
            "default": 1,
            "description": "Configured finite numerical parameter."
          },
          {
            "key": "params[7]",
            "label": "Derivative setpoint weight",
            "unit": "1",
            "default": 0,
            "description": "Configured finite numerical parameter."
          },
          {
            "key": "tables[0]",
            "label": "Initial integral state",
            "unit": "1",
            "default": [
              0
            ],
            "description": "Configured coefficients or initial values in column-major order."
          }
        ],
        "equations": [
          "e = reference − measurement",
          "I candidate = I previous + Ki × elapsed_time × e",
          "u = clamp(Kp × (b reference − measurement) + I + filtered derivative, lower, upper)"
        ],
        "example": {
          "title": "Discrete weighted PID — worked example",
          "text": "Setpoint = 1; Measurement = 0. Control at 1 s = 1.5.",
          "url": "https://design.lemonergy.com/cosim.html?example=block-native-discrete-pid",
          "label": "Open Studio example",
          "inputs": [
            {
              "port": "in0",
              "label": "Setpoint",
              "value": 1,
              "unit": "1"
            },
            {
              "port": "in1",
              "label": "Measurement",
              "value": 0,
              "unit": "1"
            }
          ],
          "checks": [
            {
              "port": "out0",
              "label": "Control",
              "atS": 1,
              "value": 1.5,
              "unit": "1",
              "tolerance": 1e-08
            }
          ]
        },
        "limits": [
          "Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed."
        ],
        "references": [
          "astrom-murray-feedback"
        ],
        "caseIds": [
          "native-native-discrete-pid"
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "exampleTraces": [
          {
            "id": "native-discrete-pid",
            "url": "https://lemonergy.com/learn/glossary/api/traces/native-discrete-pid.json?v=5a216d42acbf",
            "title": "Discrete weighted PID recorded example",
            "exampleId": "block-native-discrete-pid",
            "source": "Executed synthetic Lemonergy Studio example",
            "recordedOn": "2026-10-28",
            "points": 11,
            "channels": 1,
            "omittedChannels": 0,
            "interpolation": "step",
            "solver": {
              "method": "dormand-prince-45",
              "reason": "no-continuous-states"
            }
          }
        ],
        "type": "native-discrete-pid",
        "implementationId": "native-discrete-pid",
        "url": "https://lemonergy.com/learn/glossary/blocks/native-discrete-pid/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/native-discrete-pid/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=block-native-discrete-pid"
          ]
        },
        "studioHelp": {
          "type": "native-discrete-pid",
          "namespace": "signal",
          "slug": "signal-block-native-discrete-pid",
          "canonicalSlug": "native-discrete-pid",
          "existing": true,
          "dynamic": false,
          "scene": {
            "title": "Discrete weighted PID",
            "label": "Discrete weighted PID",
            "summary": "Combines proportional, integral and filtered derivative control with setpoint weights and limits.",
            "details": [
              "Block type: native-discrete-pid.",
              "2 declared inputs and 1 declared output in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "sampled P + I + D",
              "label": "Discrete PID control",
              "caption": "Combines proportional, integral and filtered derivative control with setpoint weights and limits."
            },
            "inputs": [
              {
                "label": "Setpoint",
                "shape": [],
                "quantity": "dimensionless",
                "elementType": "real",
                "id": "in0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              },
              {
                "label": "Measurement",
                "shape": [],
                "quantity": "dimensionless",
                "elementType": "real",
                "id": "in1",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              }
            ],
            "outputs": [
              {
                "label": "Control",
                "shape": [],
                "quantity": "dimensionless",
                "elementType": "real",
                "id": "out0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              }
            ],
            "parameters": [
              {
                "id": "config",
                "label": "Configuration",
                "unit": "",
                "value": "{\"inputs\":[{\"label\":\"Setpoint\",\"shape\":[],\"quantity\":\"inherit\",\"elementType\":\"real\"},{\"label\":\"Measurement\",\"shape\":[],\"quantity\":\"inherit\",\"elementType\":\"real\"}],\"outputs\":[{\"label\":\"Control\",\"shape\":[],\"quantity\":\"inherit\",\"elementType\":\"real\"}],\"sampleTimeS\":0.1,\"params\":[1,0.5,0,0.1,-10,10,1,0],\"tables\":[[0]]}"
              }
            ],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-native-discrete-pid/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:native-dynamic-interval",
      "type": "Block",
      "label": "Dynamic interval test",
      "properties": {
        "id": "native-dynamic-interval",
        "name": "Dynamic interval test",
        "kind": "studio",
        "summary": "Tests whether values lie between two connected bounds.",
        "behavior": "y = (connected lower ≤ u ≤ connected upper). The worked example connects this operation to signals in Lemonergy Studio.",
        "ports": [
          {
            "name": "in0",
            "direction": "input",
            "unit": "1",
            "description": "Value; real scalar.",
            "shape": [],
            "elementType": "real"
          },
          {
            "name": "in1",
            "direction": "input",
            "unit": "1",
            "description": "Lower; real scalar.",
            "shape": [],
            "elementType": "real"
          },
          {
            "name": "in2",
            "direction": "input",
            "unit": "1",
            "description": "Upper; real scalar.",
            "shape": [],
            "elementType": "real"
          },
          {
            "name": "out0",
            "direction": "output",
            "unit": "1",
            "description": "Inside; bool scalar.",
            "shape": [],
            "elementType": "bool"
          }
        ],
        "parameters": [
          {
            "key": "params[0]",
            "label": "Include lower",
            "unit": "1",
            "default": 1,
            "description": "Configured finite numerical parameter."
          },
          {
            "key": "params[1]",
            "label": "Include upper",
            "unit": "1",
            "default": 1,
            "description": "Configured finite numerical parameter."
          }
        ],
        "equations": [
          "y = (connected lower ≤ u ≤ connected upper)"
        ],
        "example": {
          "title": "Dynamic interval test — worked example",
          "text": "Value = 3; Lower = 2; Upper = 4. Inside at 0 s = 1.",
          "url": "https://design.lemonergy.com/cosim.html?example=block-native-dynamic-interval",
          "label": "Open Studio example",
          "inputs": [
            {
              "port": "in0",
              "label": "Value",
              "value": 3,
              "unit": "1"
            },
            {
              "port": "in1",
              "label": "Lower",
              "value": 2,
              "unit": "1"
            },
            {
              "port": "in2",
              "label": "Upper",
              "value": 4,
              "unit": "1"
            }
          ],
          "checks": [
            {
              "port": "out0",
              "label": "Inside",
              "atS": 0,
              "value": 1,
              "unit": "1",
              "tolerance": 1e-08
            }
          ]
        },
        "limits": [
          "Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed."
        ],
        "references": [],
        "referenceNote": "This software operation and its numerical conventions are defined by the public contract and worked example; no external research result is claimed.",
        "caseIds": [
          "native-native-dynamic-interval"
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "exampleTraces": [
          {
            "id": "native-dynamic-interval",
            "url": "https://lemonergy.com/learn/glossary/api/traces/native-dynamic-interval.json?v=79e5f8fca332",
            "title": "Dynamic interval test recorded example",
            "exampleId": "block-native-dynamic-interval",
            "source": "Executed synthetic Lemonergy Studio example",
            "recordedOn": "2026-10-28",
            "points": 2,
            "channels": 1,
            "omittedChannels": 0,
            "interpolation": "linear",
            "solver": {
              "method": "dormand-prince-45",
              "reason": "no-continuous-states"
            }
          }
        ],
        "type": "native-dynamic-interval",
        "implementationId": "native-dynamic-interval",
        "url": "https://lemonergy.com/learn/glossary/blocks/native-dynamic-interval/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/native-dynamic-interval/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=block-native-dynamic-interval"
          ]
        },
        "studioHelp": {
          "type": "native-dynamic-interval",
          "namespace": "signal",
          "slug": "signal-block-native-dynamic-interval",
          "canonicalSlug": "native-dynamic-interval",
          "existing": true,
          "dynamic": false,
          "scene": {
            "title": "Dynamic interval test",
            "label": "Dynamic interval test",
            "summary": "Tests whether values lie between two connected bounds.",
            "details": [
              "Block type: native-dynamic-interval.",
              "3 declared inputs and 1 declared output in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "input → condition → result",
              "label": "Dynamic interval test",
              "caption": "Tests whether values lie between two connected bounds."
            },
            "inputs": [
              {
                "label": "Value",
                "shape": [],
                "quantity": "dimensionless",
                "elementType": "real",
                "id": "in0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              },
              {
                "label": "Lower",
                "shape": [],
                "quantity": "dimensionless",
                "elementType": "real",
                "id": "in1",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              },
              {
                "label": "Upper",
                "shape": [],
                "quantity": "dimensionless",
                "elementType": "real",
                "id": "in2",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              }
            ],
            "outputs": [
              {
                "label": "Inside",
                "shape": [],
                "quantity": "dimensionless",
                "elementType": "bool",
                "id": "out0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "bool"
              }
            ],
            "parameters": [
              {
                "id": "config",
                "label": "Configuration",
                "unit": "",
                "value": "{\"inputs\":[{\"label\":\"Value\",\"shape\":[],\"quantity\":\"inherit\",\"elementType\":\"real\"},{\"label\":\"Lower\",\"shape\":[],\"quantity\":\"inherit\",\"elementType\":\"real\"},{\"label\":\"Upper\",\"shape\":[],\"quantity\":\"inherit\",\"elementType\":\"real\"}],\"outputs\":[{\"label\":\"Inside\",\"shape\":[],\"quantity\":\"dimensionless\",\"elementType\":\"bool\"}],\"sampleTimeS\":0,\"params\":[1,1],\"tables\":[]}"
              }
            ],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-native-dynamic-interval/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:native-extract-bits",
      "type": "Block",
      "label": "Extract bit range",
      "properties": {
        "id": "native-extract-bits",
        "name": "Extract bit range",
        "kind": "studio",
        "summary": "Extracts a contiguous bit range from an unsigned 32-bit word.",
        "behavior": "y = (word >> first_bit) AND ((1 << count) − 1). The worked example connects this operation to signals in Lemonergy Studio.",
        "ports": [
          {
            "name": "in0",
            "direction": "input",
            "unit": "1",
            "description": "Word; u32 scalar.",
            "shape": [],
            "elementType": "u32"
          },
          {
            "name": "out0",
            "direction": "output",
            "unit": "1",
            "description": "Result; u32 scalar.",
            "shape": [],
            "elementType": "u32"
          }
        ],
        "parameters": [
          {
            "key": "params[0]",
            "label": "First bit",
            "unit": "1",
            "default": 2,
            "description": "Zero-based, least significant first."
          },
          {
            "key": "params[1]",
            "label": "Bit count",
            "unit": "1",
            "default": 3,
            "description": "Configured finite numerical parameter."
          }
        ],
        "equations": [
          "y = (word >> first_bit) AND ((1 << count) − 1)"
        ],
        "example": {
          "title": "Extract bit range — worked example",
          "text": "Word = 44. Result at 0 s = 3.",
          "url": "https://design.lemonergy.com/cosim.html?example=block-native-extract-bits",
          "label": "Open Studio example",
          "inputs": [
            {
              "port": "in0",
              "label": "Word",
              "value": 44,
              "unit": "1"
            }
          ],
          "checks": [
            {
              "port": "out0",
              "label": "Result",
              "atS": 0,
              "value": 3,
              "unit": "1",
              "tolerance": 1e-08
            }
          ]
        },
        "limits": [
          "Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed."
        ],
        "references": [],
        "referenceNote": "This software operation and its numerical conventions are defined by the public contract and worked example; no external research result is claimed.",
        "caseIds": [
          "native-native-extract-bits"
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "exampleTraces": [
          {
            "id": "native-extract-bits",
            "url": "https://lemonergy.com/learn/glossary/api/traces/native-extract-bits.json?v=20d039644d19",
            "title": "Extract bit range recorded example",
            "exampleId": "block-native-extract-bits",
            "source": "Executed synthetic Lemonergy Studio example",
            "recordedOn": "2026-10-28",
            "points": 2,
            "channels": 1,
            "omittedChannels": 0,
            "interpolation": "linear",
            "solver": {
              "method": "dormand-prince-45",
              "reason": "no-continuous-states"
            }
          }
        ],
        "type": "native-extract-bits",
        "implementationId": "native-extract-bits",
        "url": "https://lemonergy.com/learn/glossary/blocks/native-extract-bits/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/native-extract-bits/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=block-native-extract-bits"
          ]
        },
        "studioHelp": {
          "type": "native-extract-bits",
          "namespace": "signal",
          "slug": "signal-block-native-extract-bits",
          "canonicalSlug": "native-extract-bits",
          "existing": true,
          "dynamic": false,
          "scene": {
            "title": "Extract bit range",
            "label": "Extract bit range",
            "summary": "Extracts a contiguous bit range from an unsigned 32-bit word.",
            "details": [
              "Block type: native-extract-bits.",
              "1 declared input and 1 declared output in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "input → condition → result",
              "label": "Extract bit range",
              "caption": "Extracts a contiguous bit range from an unsigned 32-bit word."
            },
            "inputs": [
              {
                "label": "Word",
                "shape": [],
                "quantity": "dimensionless",
                "elementType": "u32",
                "id": "in0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "u32"
              }
            ],
            "outputs": [
              {
                "label": "Result",
                "shape": [],
                "quantity": "dimensionless",
                "elementType": "u32",
                "id": "out0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "u32"
              }
            ],
            "parameters": [
              {
                "id": "config",
                "label": "Configuration",
                "unit": "",
                "value": "{\"inputs\":[{\"label\":\"Word\",\"shape\":[],\"quantity\":\"dimensionless\",\"elementType\":\"u32\"}],\"outputs\":[{\"label\":\"Result\",\"shape\":[],\"quantity\":\"dimensionless\",\"elementType\":\"u32\"}],\"sampleTimeS\":0,\"params\":[2,3],\"tables\":[]}"
              }
            ],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-native-extract-bits/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:native-float32-bits",
      "type": "Block",
      "label": "Float32 bit pattern",
      "properties": {
        "id": "native-float32-bits",
        "name": "Float32 bit pattern",
        "kind": "studio",
        "summary": "Exposes the binary32 representation of a numeric value as an unsigned word.",
        "behavior": "y = binary32 bit pattern of rounded input, represented as exact u32. The worked example connects this operation to signals in Lemonergy Studio.",
        "ports": [
          {
            "name": "in0",
            "direction": "input",
            "unit": "1",
            "description": "Value; real scalar.",
            "shape": [],
            "elementType": "real"
          },
          {
            "name": "out0",
            "direction": "output",
            "unit": "1",
            "description": "Bit pattern; u32 scalar.",
            "shape": [],
            "elementType": "u32"
          }
        ],
        "parameters": [],
        "equations": [
          "y = binary32 bit pattern of rounded input, represented as exact u32"
        ],
        "example": {
          "title": "Float32 bit pattern — worked example",
          "text": "Value = 1. Bit pattern at 0 s = 1065353216.",
          "url": "https://design.lemonergy.com/cosim.html?example=block-native-float32-bits",
          "label": "Open Studio example",
          "inputs": [
            {
              "port": "in0",
              "label": "Value",
              "value": 1,
              "unit": "1"
            }
          ],
          "checks": [
            {
              "port": "out0",
              "label": "Bit pattern",
              "atS": 0,
              "value": 1065353216,
              "unit": "1",
              "tolerance": 1e-08
            }
          ]
        },
        "limits": [
          "Finite f64 values are rounded to binary32 then exposed as an exact u32 bit pattern. Binary64 decomposition and configurable sign/exponent/mantissa fields are not implemented.",
          "Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed."
        ],
        "references": [],
        "referenceNote": "This software operation and its numerical conventions are defined by the public contract and worked example; no external research result is claimed.",
        "caseIds": [
          "native-native-float32-bits"
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "exampleTraces": [
          {
            "id": "native-float32-bits",
            "url": "https://lemonergy.com/learn/glossary/api/traces/native-float32-bits.json?v=85c7f57292ca",
            "title": "Float32 bit pattern recorded example",
            "exampleId": "block-native-float32-bits",
            "source": "Executed synthetic Lemonergy Studio example",
            "recordedOn": "2026-10-28",
            "points": 2,
            "channels": 1,
            "omittedChannels": 0,
            "interpolation": "linear",
            "solver": {
              "method": "dormand-prince-45",
              "reason": "no-continuous-states"
            }
          }
        ],
        "type": "native-float32-bits",
        "implementationId": "native-float32-bits",
        "url": "https://lemonergy.com/learn/glossary/blocks/native-float32-bits/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/native-float32-bits/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=block-native-float32-bits"
          ]
        },
        "studioHelp": {
          "type": "native-float32-bits",
          "namespace": "signal",
          "slug": "signal-block-native-float32-bits",
          "canonicalSlug": "native-float32-bits",
          "existing": true,
          "dynamic": false,
          "scene": {
            "title": "Float32 bit pattern",
            "label": "Float32 bit pattern",
            "summary": "Exposes the binary32 representation of a numeric value as an unsigned word.",
            "details": [
              "Block type: native-float32-bits.",
              "1 declared input and 1 declared output in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "input → condition → result",
              "label": "Float32 bit pattern",
              "caption": "Exposes the binary32 representation of a numeric value as an unsigned word."
            },
            "inputs": [
              {
                "label": "Value",
                "shape": [],
                "quantity": "dimensionless",
                "elementType": "real",
                "id": "in0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              }
            ],
            "outputs": [
              {
                "label": "Bit pattern",
                "shape": [],
                "quantity": "dimensionless",
                "elementType": "u32",
                "id": "out0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "u32"
              }
            ],
            "parameters": [
              {
                "id": "config",
                "label": "Configuration",
                "unit": "",
                "value": "{\"inputs\":[{\"label\":\"Value\",\"shape\":[],\"quantity\":\"inherit\",\"elementType\":\"real\"}],\"outputs\":[{\"label\":\"Bit pattern\",\"shape\":[],\"quantity\":\"dimensionless\",\"elementType\":\"u32\"}],\"sampleTimeS\":0,\"params\":[],\"tables\":[]}"
              }
            ],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-native-float32-bits/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:native-integer-bits",
      "type": "Block",
      "label": "Integer to Boolean bits",
      "properties": {
        "id": "native-integer-bits",
        "name": "Integer to Boolean bits",
        "kind": "studio",
        "summary": "Expands an unsigned word into Boolean bits, least significant bit first.",
        "behavior": "bitᵢ = (word >> i) AND 1. The worked example connects this operation to signals in Lemonergy Studio.",
        "ports": [
          {
            "name": "in0",
            "direction": "input",
            "unit": "1",
            "description": "Word; u32 scalar.",
            "shape": [],
            "elementType": "u32"
          },
          {
            "name": "out0",
            "direction": "output",
            "unit": "1",
            "description": "Bits; bool 4 array.",
            "shape": [
              4
            ],
            "elementType": "bool"
          }
        ],
        "parameters": [],
        "equations": [
          "bitᵢ = (word >> i) AND 1"
        ],
        "example": {
          "title": "Integer to Boolean bits — worked example",
          "text": "Word = 13. Bits at 0 s = [1,0,1,1].",
          "url": "https://design.lemonergy.com/cosim.html?example=block-native-integer-bits",
          "label": "Open Studio example",
          "inputs": [
            {
              "port": "in0",
              "label": "Word",
              "value": 13,
              "unit": "1"
            }
          ],
          "checks": [
            {
              "port": "out0",
              "label": "Bits",
              "atS": 0,
              "value": [
                1,
                0,
                1,
                1
              ],
              "unit": "1",
              "tolerance": 1e-08
            }
          ]
        },
        "limits": [
          "Exact u32 to configured width≤32 Boolean outputs, least significant first.",
          "Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed."
        ],
        "references": [],
        "referenceNote": "This software operation and its numerical conventions are defined by the public contract and worked example; no external research result is claimed.",
        "caseIds": [
          "native-native-integer-bits"
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "exampleTraces": [
          {
            "id": "native-integer-bits",
            "url": "https://lemonergy.com/learn/glossary/api/traces/native-integer-bits.json?v=9fdad0101dba",
            "title": "Integer to Boolean bits recorded example",
            "exampleId": "block-native-integer-bits",
            "source": "Executed synthetic Lemonergy Studio example",
            "recordedOn": "2026-10-28",
            "points": 2,
            "channels": 4,
            "omittedChannels": 0,
            "interpolation": "linear",
            "solver": {
              "method": "dormand-prince-45",
              "reason": "no-continuous-states"
            }
          }
        ],
        "type": "native-integer-bits",
        "implementationId": "native-integer-bits",
        "url": "https://lemonergy.com/learn/glossary/blocks/native-integer-bits/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/native-integer-bits/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=block-native-integer-bits"
          ]
        },
        "studioHelp": {
          "type": "native-integer-bits",
          "namespace": "signal",
          "slug": "signal-block-native-integer-bits",
          "canonicalSlug": "native-integer-bits",
          "existing": true,
          "dynamic": false,
          "scene": {
            "title": "Integer to Boolean bits",
            "label": "Integer to Boolean bits",
            "summary": "Expands an unsigned word into Boolean bits, least significant bit first.",
            "details": [
              "Block type: native-integer-bits.",
              "1 declared input and 1 declared output in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "input → condition → result",
              "label": "Integer to Boolean bits",
              "caption": "Expands an unsigned word into Boolean bits, least significant bit first."
            },
            "inputs": [
              {
                "label": "Word",
                "shape": [],
                "quantity": "dimensionless",
                "elementType": "u32",
                "id": "in0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "u32"
              }
            ],
            "outputs": [
              {
                "label": "Bits",
                "shape": [
                  4
                ],
                "quantity": "dimensionless",
                "elementType": "bool",
                "id": "out0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Array 4",
                "elementLabel": "bool"
              }
            ],
            "parameters": [
              {
                "id": "config",
                "label": "Configuration",
                "unit": "",
                "value": "{\"inputs\":[{\"label\":\"Word\",\"shape\":[],\"quantity\":\"dimensionless\",\"elementType\":\"u32\"}],\"outputs\":[{\"label\":\"Bits\",\"shape\":[4],\"quantity\":\"dimensionless\",\"elementType\":\"bool\"}],\"sampleTimeS\":0,\"params\":[],\"tables\":[]}"
              }
            ],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-native-integer-bits/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:native-interval-test",
      "type": "Block",
      "label": "Interval test",
      "properties": {
        "id": "native-interval-test",
        "name": "Interval test",
        "kind": "studio",
        "summary": "Tests whether values lie inside configured lower and upper boundaries.",
        "behavior": "y = (lower ≤ u ≤ upper), with independently configurable open endpoints. The worked example connects this operation to signals in Lemonergy Studio.",
        "ports": [
          {
            "name": "in0",
            "direction": "input",
            "unit": "1",
            "description": "Value; real scalar.",
            "shape": [],
            "elementType": "real"
          },
          {
            "name": "out0",
            "direction": "output",
            "unit": "1",
            "description": "Inside; bool scalar.",
            "shape": [],
            "elementType": "bool"
          }
        ],
        "parameters": [
          {
            "key": "params[0]",
            "label": "Lower limit",
            "unit": "1",
            "default": 2,
            "description": "Configured finite numerical parameter."
          },
          {
            "key": "params[1]",
            "label": "Upper limit",
            "unit": "1",
            "default": 4,
            "description": "Configured finite numerical parameter."
          },
          {
            "key": "params[2]",
            "label": "Include lower",
            "unit": "1",
            "default": 1,
            "description": "1 inclusive; 0 exclusive."
          },
          {
            "key": "params[3]",
            "label": "Include upper",
            "unit": "1",
            "default": 1,
            "description": "Configured finite numerical parameter."
          }
        ],
        "equations": [
          "y = (lower ≤ u ≤ upper), with independently configurable open endpoints"
        ],
        "example": {
          "title": "Interval test — worked example",
          "text": "Value = 3. Inside at 0 s = 1.",
          "url": "https://design.lemonergy.com/cosim.html?example=block-native-interval-test",
          "label": "Open Studio example",
          "inputs": [
            {
              "port": "in0",
              "label": "Value",
              "value": 3,
              "unit": "1"
            }
          ],
          "checks": [
            {
              "port": "out0",
              "label": "Inside",
              "atS": 0,
              "value": 1,
              "unit": "1",
              "tolerance": 1e-08
            }
          ]
        },
        "limits": [
          "Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed."
        ],
        "references": [],
        "referenceNote": "This software operation and its numerical conventions are defined by the public contract and worked example; no external research result is claimed.",
        "caseIds": [
          "native-native-interval-test"
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "exampleTraces": [
          {
            "id": "native-interval-test",
            "url": "https://lemonergy.com/learn/glossary/api/traces/native-interval-test.json?v=b8b489c05a25",
            "title": "Interval test recorded example",
            "exampleId": "block-native-interval-test",
            "source": "Executed synthetic Lemonergy Studio example",
            "recordedOn": "2026-10-28",
            "points": 2,
            "channels": 1,
            "omittedChannels": 0,
            "interpolation": "linear",
            "solver": {
              "method": "dormand-prince-45",
              "reason": "no-continuous-states"
            }
          }
        ],
        "type": "native-interval-test",
        "implementationId": "native-interval-test",
        "url": "https://lemonergy.com/learn/glossary/blocks/native-interval-test/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/native-interval-test/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=block-native-interval-test"
          ]
        },
        "studioHelp": {
          "type": "native-interval-test",
          "namespace": "signal",
          "slug": "signal-block-native-interval-test",
          "canonicalSlug": "native-interval-test",
          "existing": true,
          "dynamic": false,
          "scene": {
            "title": "Interval test",
            "label": "Interval test",
            "summary": "Tests whether values lie inside configured lower and upper boundaries.",
            "details": [
              "Block type: native-interval-test.",
              "1 declared input and 1 declared output in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "input → condition → result",
              "label": "Interval test",
              "caption": "Tests whether values lie inside configured lower and upper boundaries."
            },
            "inputs": [
              {
                "label": "Value",
                "shape": [],
                "quantity": "dimensionless",
                "elementType": "real",
                "id": "in0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              }
            ],
            "outputs": [
              {
                "label": "Inside",
                "shape": [],
                "quantity": "dimensionless",
                "elementType": "bool",
                "id": "out0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "bool"
              }
            ],
            "parameters": [
              {
                "id": "config",
                "label": "Configuration",
                "unit": "",
                "value": "{\"inputs\":[{\"label\":\"Value\",\"shape\":[],\"quantity\":\"inherit\",\"elementType\":\"real\"}],\"outputs\":[{\"label\":\"Inside\",\"shape\":[],\"quantity\":\"dimensionless\",\"elementType\":\"bool\"}],\"sampleTimeS\":0,\"params\":[2,4,1,1],\"tables\":[]}"
              }
            ],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-native-interval-test/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:native-manual-switch",
      "type": "Block",
      "label": "Manual switch",
      "properties": {
        "id": "native-manual-switch",
        "name": "Manual switch",
        "kind": "studio",
        "summary": "Selects a configured input without changing its shape, units or element type.",
        "behavior": "y = data[configured index].",
        "ports": [
          {
            "name": "in0",
            "direction": "input",
            "unit": "1",
            "description": "First signal; real 3 array.",
            "shape": [
              3
            ],
            "elementType": "real"
          },
          {
            "name": "in1",
            "direction": "input",
            "unit": "1",
            "description": "Second signal; real 3 array.",
            "shape": [
              3
            ],
            "elementType": "real"
          },
          {
            "name": "out0",
            "direction": "output",
            "unit": "1",
            "description": "Selected signal; real 3 array.",
            "shape": [
              3
            ],
            "elementType": "real"
          }
        ],
        "parameters": [
          {
            "key": "params[0]",
            "label": "Selected input (zero-based)",
            "unit": "1",
            "default": 1,
            "description": "Configured value for Selected input (zero-based)."
          }
        ],
        "equations": [
          "y = data[configured index]"
        ],
        "example": {
          "title": "Manual switch — worked example",
          "text": "First signal = [1,2,3]; Second signal = [4,5,6]. Selected signal at 0 s = [4,5,6].",
          "url": "https://design.lemonergy.com/cosim.html?example=block-native-manual-switch",
          "label": "Open Studio example",
          "inputs": [
            {
              "port": "in0",
              "label": "First signal",
              "value": [
                1,
                2,
                3
              ],
              "unit": "1"
            },
            {
              "port": "in1",
              "label": "Second signal",
              "value": [
                4,
                5,
                6
              ],
              "unit": "1"
            }
          ],
          "checks": [
            {
              "port": "out0",
              "label": "Selected signal",
              "atS": 0,
              "value": [
                4,
                5,
                6
              ],
              "unit": "1",
              "tolerance": 1e-09
            }
          ]
        },
        "limits": [
          "The selected input is configured before the run; this is not a mid-run interactive control."
        ],
        "references": [],
        "referenceNote": "This software operation is defined by its public contract and worked example; no external research result is claimed.",
        "caseIds": [
          "native-native-manual-switch"
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "exampleTraces": [
          {
            "id": "native-manual-switch",
            "url": "https://lemonergy.com/learn/glossary/api/traces/native-manual-switch.json?v=144f52865c8a",
            "title": "Manual switch recorded example",
            "exampleId": "block-native-manual-switch",
            "source": "Executed synthetic Lemonergy Studio example",
            "recordedOn": "2026-10-28",
            "points": 2,
            "channels": 3,
            "omittedChannels": 0,
            "interpolation": "linear",
            "solver": {
              "method": "dormand-prince-45",
              "reason": "no-continuous-states"
            }
          }
        ],
        "type": "native-manual-switch",
        "implementationId": "native-manual-switch",
        "url": "https://lemonergy.com/learn/glossary/blocks/native-manual-switch/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/native-manual-switch/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=block-native-manual-switch"
          ]
        },
        "studioHelp": {
          "type": "native-manual-switch",
          "namespace": "signal",
          "slug": "signal-block-native-manual-switch",
          "canonicalSlug": "native-manual-switch",
          "existing": true,
          "dynamic": false,
          "scene": {
            "title": "Manual switch",
            "label": "Manual switch",
            "summary": "Selects a configured input without changing its shape, units or element type.",
            "details": [
              "Block type: native-manual-switch.",
              "2 declared inputs and 1 declared output in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "condition → branch",
              "label": "Selection and control",
              "caption": "Selects a configured input without changing its shape, units or element type."
            },
            "inputs": [
              {
                "label": "First signal",
                "shape": [
                  3
                ],
                "elementType": "real",
                "quantity": "dimensionless",
                "id": "in0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Array 3",
                "elementLabel": "real"
              },
              {
                "label": "Second signal",
                "shape": [
                  3
                ],
                "elementType": "real",
                "quantity": "dimensionless",
                "id": "in1",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Array 3",
                "elementLabel": "real"
              }
            ],
            "outputs": [
              {
                "label": "Selected signal",
                "shape": [
                  3
                ],
                "elementType": "real",
                "quantity": "dimensionless",
                "id": "out0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Array 3",
                "elementLabel": "real"
              }
            ],
            "parameters": [
              {
                "id": "config",
                "label": "Configuration",
                "unit": "",
                "value": "{\"inputs\":[{\"label\":\"First signal\",\"shape\":[3],\"elementType\":\"real\",\"quantity\":\"dimensionless\"},{\"label\":\"Second signal\",\"shape\":[3],\"elementType\":\"real\",\"quantity\":\"dimensionless\"}],\"outputs\":[{\"label\":\"Selected signal\",\"shape\":[3],\"elementType\":\"real\",\"quantity\":\"dimensionless\"}],\"params\":[1],\"sampleTimeS\":0}"
              }
            ],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-native-manual-switch/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:native-multiport-switch",
      "type": "Block",
      "label": "Multiport switch",
      "properties": {
        "id": "native-multiport-switch",
        "name": "Multiport switch",
        "kind": "studio",
        "summary": "Routes one whole data port selected by a zero-based integer. Out-of-range indices stop the run.",
        "behavior": "y = data[index], where index is a zero-based signed integer.",
        "ports": [
          {
            "name": "in0",
            "direction": "input",
            "unit": "1",
            "description": "Index; i32 scalar.",
            "shape": [],
            "elementType": "i32"
          },
          {
            "name": "in1",
            "direction": "input",
            "unit": "1",
            "description": "First signal; real 3 array.",
            "shape": [
              3
            ],
            "elementType": "real"
          },
          {
            "name": "in2",
            "direction": "input",
            "unit": "1",
            "description": "Second signal; real 3 array.",
            "shape": [
              3
            ],
            "elementType": "real"
          },
          {
            "name": "out0",
            "direction": "output",
            "unit": "1",
            "description": "Selected signal; real 3 array.",
            "shape": [
              3
            ],
            "elementType": "real"
          }
        ],
        "parameters": [],
        "equations": [
          "y = data[index], where index is a zero-based signed integer"
        ],
        "example": {
          "title": "Multiport switch — worked example",
          "text": "Index = 1; First signal = [1,2,3]; Second signal = [4,5,6]. Selected signal at 0 s = [4,5,6].",
          "url": "https://design.lemonergy.com/cosim.html?example=block-native-multiport-switch",
          "label": "Open Studio example",
          "inputs": [
            {
              "port": "in0",
              "label": "Index",
              "value": 1,
              "unit": "1"
            },
            {
              "port": "in1",
              "label": "First signal",
              "value": [
                1,
                2,
                3
              ],
              "unit": "1"
            },
            {
              "port": "in2",
              "label": "Second signal",
              "value": [
                4,
                5,
                6
              ],
              "unit": "1"
            }
          ],
          "checks": [
            {
              "port": "out0",
              "label": "Selected signal",
              "atS": 0,
              "value": [
                4,
                5,
                6
              ],
              "unit": "1",
              "tolerance": 1e-09
            }
          ]
        },
        "limits": [
          "All data inputs must have exactly the output shape, quantity and element type; an invalid index stops execution."
        ],
        "references": [],
        "referenceNote": "This software operation is defined by its public contract and worked example; no external research result is claimed.",
        "caseIds": [
          "native-native-multiport-switch"
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "exampleTraces": [
          {
            "id": "native-multiport-switch",
            "url": "https://lemonergy.com/learn/glossary/api/traces/native-multiport-switch.json?v=1b786b39cba0",
            "title": "Multiport switch recorded example",
            "exampleId": "block-native-multiport-switch",
            "source": "Executed synthetic Lemonergy Studio example",
            "recordedOn": "2026-10-28",
            "points": 2,
            "channels": 3,
            "omittedChannels": 0,
            "interpolation": "linear",
            "solver": {
              "method": "dormand-prince-45",
              "reason": "no-continuous-states"
            }
          }
        ],
        "type": "native-multiport-switch",
        "implementationId": "native-multiport-switch",
        "url": "https://lemonergy.com/learn/glossary/blocks/native-multiport-switch/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/native-multiport-switch/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=block-native-multiport-switch"
          ]
        },
        "studioHelp": {
          "type": "native-multiport-switch",
          "namespace": "signal",
          "slug": "signal-block-native-multiport-switch",
          "canonicalSlug": "native-multiport-switch",
          "existing": true,
          "dynamic": false,
          "scene": {
            "title": "Multiport switch",
            "label": "Multiport switch",
            "summary": "Routes one whole data port selected by a zero-based integer. Out-of-range indices stop the run.",
            "details": [
              "Block type: native-multiport-switch.",
              "3 declared inputs and 1 declared output in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "condition → branch",
              "label": "Selection and control",
              "caption": "Routes one whole data port selected by a zero-based integer. Out-of-range indices stop the run."
            },
            "inputs": [
              {
                "label": "Index",
                "shape": [],
                "elementType": "i32",
                "quantity": "dimensionless",
                "id": "in0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "i32"
              },
              {
                "label": "First signal",
                "shape": [
                  3
                ],
                "elementType": "real",
                "quantity": "dimensionless",
                "id": "in1",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Array 3",
                "elementLabel": "real"
              },
              {
                "label": "Second signal",
                "shape": [
                  3
                ],
                "elementType": "real",
                "quantity": "dimensionless",
                "id": "in2",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Array 3",
                "elementLabel": "real"
              }
            ],
            "outputs": [
              {
                "label": "Selected signal",
                "shape": [
                  3
                ],
                "elementType": "real",
                "quantity": "dimensionless",
                "id": "out0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Array 3",
                "elementLabel": "real"
              }
            ],
            "parameters": [
              {
                "id": "config",
                "label": "Configuration",
                "unit": "",
                "value": "{\"inputs\":[{\"label\":\"Index\",\"shape\":[],\"elementType\":\"i32\",\"quantity\":\"dimensionless\"},{\"label\":\"First signal\",\"shape\":[3],\"elementType\":\"real\",\"quantity\":\"dimensionless\"},{\"label\":\"Second signal\",\"shape\":[3],\"elementType\":\"real\",\"quantity\":\"dimensionless\"}],\"outputs\":[{\"label\":\"Selected signal\",\"shape\":[3],\"elementType\":\"real\",\"quantity\":\"dimensionless\"}],\"params\":[],\"sampleTimeS\":0}"
              }
            ],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-native-multiport-switch/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:native-pid",
      "type": "Block",
      "label": "Continuous weighted PID",
      "properties": {
        "id": "native-pid",
        "name": "Continuous weighted PID",
        "kind": "studio",
        "summary": "Combines continuous proportional, integral and filtered derivative control with weights and limits.",
        "behavior": "dx_integral/dt = Ki (reference − measurement), subject to conditional integration. τ dx_filter/dt = c reference − measurement − x_filter. u = clamp(Kp (b reference − measurement) + x_integral + Kd dx_filter/dt, lower, upper). The worked example connects this operation to signals in Lemonergy Studio.",
        "ports": [
          {
            "name": "in0",
            "direction": "input",
            "unit": "1",
            "description": "Setpoint; real scalar.",
            "shape": [],
            "elementType": "real"
          },
          {
            "name": "in1",
            "direction": "input",
            "unit": "1",
            "description": "Measurement; real scalar.",
            "shape": [],
            "elementType": "real"
          },
          {
            "name": "out0",
            "direction": "output",
            "unit": "1",
            "description": "Control; real scalar.",
            "shape": [],
            "elementType": "real"
          }
        ],
        "parameters": [
          {
            "key": "params[0]",
            "label": "Proportional gain",
            "unit": "1",
            "default": 1,
            "description": "Configured finite numerical parameter."
          },
          {
            "key": "params[1]",
            "label": "Integral gain",
            "unit": "1",
            "default": 0.5,
            "description": "Configured finite numerical parameter."
          },
          {
            "key": "params[2]",
            "label": "Derivative gain",
            "unit": "1",
            "default": 0,
            "description": "Configured finite numerical parameter."
          },
          {
            "key": "params[3]",
            "label": "Derivative filter time",
            "unit": "s",
            "default": 0.1,
            "description": "Configured finite numerical parameter."
          },
          {
            "key": "params[4]",
            "label": "Lower output limit",
            "unit": "1",
            "default": -10,
            "description": "Configured finite numerical parameter."
          },
          {
            "key": "params[5]",
            "label": "Upper output limit",
            "unit": "1",
            "default": 10,
            "description": "Configured finite numerical parameter."
          },
          {
            "key": "params[6]",
            "label": "Proportional setpoint weight",
            "unit": "1",
            "default": 1,
            "description": "Configured finite numerical parameter."
          },
          {
            "key": "params[7]",
            "label": "Derivative setpoint weight",
            "unit": "1",
            "default": 0,
            "description": "Configured finite numerical parameter."
          },
          {
            "key": "tables[0]",
            "label": "Initial states",
            "unit": "1",
            "default": [
              0,
              0
            ],
            "description": "Integral output, derivative filter state."
          }
        ],
        "equations": [
          "dx_integral/dt = Ki (reference − measurement), subject to conditional integration",
          "τ dx_filter/dt = c reference − measurement − x_filter",
          "u = clamp(Kp (b reference − measurement) + x_integral + Kd dx_filter/dt, lower, upper)"
        ],
        "example": {
          "title": "Continuous weighted PID — worked example",
          "text": "Setpoint = 1; Measurement = 0. Control at 1 s = 1.5.",
          "url": "https://design.lemonergy.com/cosim.html?example=block-native-pid",
          "label": "Open Studio example",
          "inputs": [
            {
              "port": "in0",
              "label": "Setpoint",
              "value": 1,
              "unit": "1"
            },
            {
              "port": "in1",
              "label": "Measurement",
              "value": 0,
              "unit": "1"
            }
          ],
          "checks": [
            {
              "port": "out0",
              "label": "Control",
              "atS": 1,
              "value": 1.5,
              "unit": "1",
              "tolerance": 2e-06
            }
          ]
        },
        "limits": [
          "Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed."
        ],
        "references": [
          "astrom-murray-feedback"
        ],
        "caseIds": [
          "native-native-pid"
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "exampleTraces": [
          {
            "id": "native-pid",
            "url": "https://lemonergy.com/learn/glossary/api/traces/native-pid.json?v=cd80f576b793",
            "title": "Continuous weighted PID recorded example",
            "exampleId": "block-native-pid",
            "source": "Executed synthetic Lemonergy Studio example",
            "recordedOn": "2026-10-28",
            "points": 13,
            "channels": 1,
            "omittedChannels": 0,
            "interpolation": "linear",
            "solver": {
              "method": "dormand-prince-45",
              "reason": "non-stiff-time-scales"
            }
          }
        ],
        "type": "native-pid",
        "implementationId": "native-pid",
        "url": "https://lemonergy.com/learn/glossary/blocks/native-pid/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/native-pid/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=block-native-pid"
          ]
        },
        "studioHelp": {
          "type": "native-pid",
          "namespace": "signal",
          "slug": "signal-block-native-pid",
          "canonicalSlug": "native-pid",
          "existing": true,
          "dynamic": false,
          "scene": {
            "title": "Continuous weighted PID",
            "label": "Continuous weighted PID",
            "summary": "Combines continuous proportional, integral and filtered derivative control with weights and limits.",
            "details": [
              "Block type: native-pid.",
              "2 declared inputs and 1 declared output in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "P + I + filtered D",
              "label": "Continuous PID control",
              "caption": "Combines continuous proportional, integral and filtered derivative control with weights and limits."
            },
            "inputs": [
              {
                "label": "Setpoint",
                "shape": [],
                "quantity": "dimensionless",
                "elementType": "real",
                "id": "in0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              },
              {
                "label": "Measurement",
                "shape": [],
                "quantity": "dimensionless",
                "elementType": "real",
                "id": "in1",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              }
            ],
            "outputs": [
              {
                "label": "Control",
                "shape": [],
                "quantity": "dimensionless",
                "elementType": "real",
                "id": "out0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              }
            ],
            "parameters": [
              {
                "id": "config",
                "label": "Configuration",
                "unit": "",
                "value": "{\"inputs\":[{\"label\":\"Setpoint\",\"shape\":[],\"quantity\":\"inherit\",\"elementType\":\"real\"},{\"label\":\"Measurement\",\"shape\":[],\"quantity\":\"inherit\",\"elementType\":\"real\"}],\"outputs\":[{\"label\":\"Control\",\"shape\":[],\"quantity\":\"inherit\",\"elementType\":\"real\"}],\"sampleTimeS\":0,\"params\":[1,0.5,0,0.1,-10,10,1,0],\"tables\":[[0,0]]}"
              }
            ],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-native-pid/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:native-selector",
      "type": "Block",
      "label": "Element selector",
      "properties": {
        "id": "native-selector",
        "name": "Element selector",
        "kind": "studio",
        "summary": "Selects column-major array elements by explicit zero-based indices, preserving their order and type.",
        "behavior": "output i = input[configured index i].",
        "ports": [
          {
            "name": "in0",
            "direction": "input",
            "unit": "1",
            "description": "Array; real 3 array.",
            "shape": [
              3
            ],
            "elementType": "real"
          },
          {
            "name": "out0",
            "direction": "output",
            "unit": "1",
            "description": "Selected elements; real 2 array.",
            "shape": [
              2
            ],
            "elementType": "real"
          }
        ],
        "parameters": [
          {
            "key": "params[0]",
            "label": "First selected index",
            "unit": "1",
            "default": 2,
            "description": "Configured value for First selected index."
          },
          {
            "key": "params[1]",
            "label": "Second selected index",
            "unit": "1",
            "default": 0,
            "description": "Configured value for Second selected index."
          }
        ],
        "equations": [
          "output i = input[configured index i]"
        ],
        "example": {
          "title": "Element selector — worked example",
          "text": "Array = [2,4,6]. Selected elements at 0 s = [6,2].",
          "url": "https://design.lemonergy.com/cosim.html?example=block-native-selector",
          "label": "Open Studio example",
          "inputs": [
            {
              "port": "in0",
              "label": "Array",
              "value": [
                2,
                4,
                6
              ],
              "unit": "1"
            }
          ],
          "checks": [
            {
              "port": "out0",
              "label": "Selected elements",
              "atS": 0,
              "value": [
                6,
                2
              ],
              "unit": "1",
              "tolerance": 1e-09
            }
          ]
        },
        "limits": [
          "Indices are configured before execution, zero-based and interpreted in column-major element order."
        ],
        "references": [],
        "referenceNote": "This software operation is defined by its public contract and worked example; no external research result is claimed.",
        "caseIds": [
          "native-native-selector"
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "exampleTraces": [
          {
            "id": "native-selector",
            "url": "https://lemonergy.com/learn/glossary/api/traces/native-selector.json?v=b5918ca9662f",
            "title": "Element selector recorded example",
            "exampleId": "block-native-selector",
            "source": "Executed synthetic Lemonergy Studio example",
            "recordedOn": "2026-10-28",
            "points": 2,
            "channels": 2,
            "omittedChannels": 0,
            "interpolation": "linear",
            "solver": {
              "method": "dormand-prince-45",
              "reason": "no-continuous-states"
            }
          }
        ],
        "type": "native-selector",
        "implementationId": "native-selector",
        "url": "https://lemonergy.com/learn/glossary/blocks/native-selector/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/native-selector/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=block-native-selector"
          ]
        },
        "studioHelp": {
          "type": "native-selector",
          "namespace": "signal",
          "slug": "signal-block-native-selector",
          "canonicalSlug": "native-selector",
          "existing": true,
          "dynamic": false,
          "scene": {
            "title": "Element selector",
            "label": "Element selector",
            "summary": "Selects column-major array elements by explicit zero-based indices, preserving their order and type.",
            "details": [
              "Block type: native-selector.",
              "1 declared input and 1 declared output in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "condition → branch",
              "label": "Selection and control",
              "caption": "Selects column-major array elements by explicit zero-based indices, preserving their order and type."
            },
            "inputs": [
              {
                "label": "Array",
                "shape": [
                  3
                ],
                "elementType": "real",
                "quantity": "dimensionless",
                "id": "in0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Array 3",
                "elementLabel": "real"
              }
            ],
            "outputs": [
              {
                "label": "Selected elements",
                "shape": [
                  2
                ],
                "elementType": "real",
                "quantity": "dimensionless",
                "id": "out0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Array 2",
                "elementLabel": "real"
              }
            ],
            "parameters": [
              {
                "id": "config",
                "label": "Configuration",
                "unit": "",
                "value": "{\"inputs\":[{\"label\":\"Array\",\"shape\":[3],\"elementType\":\"real\",\"quantity\":\"dimensionless\"}],\"outputs\":[{\"label\":\"Selected elements\",\"shape\":[2],\"elementType\":\"real\",\"quantity\":\"dimensionless\"}],\"params\":[2,0],\"sampleTimeS\":0}"
              }
            ],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-native-selector/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:native-stop-simulation",
      "type": "Block",
      "label": "Stop simulation",
      "properties": {
        "id": "native-stop-simulation",
        "name": "Stop simulation",
        "kind": "studio",
        "summary": "Finishes the run successfully at the first sample where the Boolean condition is true, preserving the trace and recording the stop reason.",
        "behavior": "stop at first sampled condition = true; preserve the trace through that instant.",
        "ports": [
          {
            "name": "in0",
            "direction": "input",
            "unit": "1",
            "description": "Stop requested; bool scalar.",
            "shape": [],
            "elementType": "bool"
          },
          {
            "name": "out0",
            "direction": "output",
            "unit": "1",
            "description": "Stop accepted; bool scalar.",
            "shape": [],
            "elementType": "bool"
          }
        ],
        "parameters": [
          {
            "key": "sampleTimeS",
            "label": "Sample period",
            "unit": "s",
            "default": 0.1,
            "min": 0,
            "description": "Positive interval between sample instants. Values are held between samples."
          }
        ],
        "equations": [
          "stop at first sampled condition = true; preserve the trace through that instant"
        ],
        "example": {
          "title": "Stop simulation — worked example",
          "text": "Stop requested = 0. Stop accepted at 0 s = 0.",
          "url": "https://design.lemonergy.com/cosim.html?example=block-native-stop-simulation",
          "label": "Open Studio example",
          "inputs": [
            {
              "port": "in0",
              "label": "Stop requested",
              "value": 0,
              "unit": "1"
            }
          ],
          "checks": [
            {
              "port": "out0",
              "label": "Stop accepted",
              "atS": 0,
              "value": 0,
              "unit": "1",
              "tolerance": 1e-09
            }
          ]
        },
        "limits": [
          "Requests are evaluated on the configured sample grid; a condition between samples is acted on at the next sample."
        ],
        "references": [],
        "referenceNote": "This software operation is defined by its public contract and worked example; no external research result is claimed.",
        "caseIds": [
          "native-native-stop-simulation"
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "exampleTraces": [
          {
            "id": "native-stop-simulation",
            "url": "https://lemonergy.com/learn/glossary/api/traces/native-stop-simulation.json?v=04bb8a134089",
            "title": "Stop simulation recorded example",
            "exampleId": "block-native-stop-simulation",
            "source": "Executed synthetic Lemonergy Studio example",
            "recordedOn": "2026-10-28",
            "points": 11,
            "channels": 1,
            "omittedChannels": 0,
            "interpolation": "step",
            "solver": {
              "method": "dormand-prince-45",
              "reason": "no-continuous-states"
            }
          }
        ],
        "type": "native-stop-simulation",
        "implementationId": "native-stop-simulation",
        "url": "https://lemonergy.com/learn/glossary/blocks/native-stop-simulation/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/native-stop-simulation/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=block-native-stop-simulation"
          ]
        },
        "studioHelp": {
          "type": "native-stop-simulation",
          "namespace": "signal",
          "slug": "signal-block-native-stop-simulation",
          "canonicalSlug": "native-stop-simulation",
          "existing": true,
          "dynamic": false,
          "scene": {
            "title": "Stop simulation",
            "label": "Stop simulation",
            "summary": "Finishes the run successfully at the first sample where the Boolean condition is true, preserving the trace and recording the stop reason.",
            "details": [
              "Block type: native-stop-simulation.",
              "1 declared input and 1 declared output in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "input → condition → result",
              "label": "Stop simulation",
              "caption": "Finishes the run successfully at the first sample where the Boolean condition is true, preserving the trace and recording the stop reason."
            },
            "inputs": [
              {
                "label": "Stop requested",
                "shape": [],
                "elementType": "bool",
                "quantity": "dimensionless",
                "id": "in0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "bool"
              }
            ],
            "outputs": [
              {
                "label": "Stop accepted",
                "shape": [],
                "elementType": "bool",
                "quantity": "dimensionless",
                "id": "out0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "bool"
              }
            ],
            "parameters": [
              {
                "id": "config",
                "label": "Configuration",
                "unit": "",
                "value": "{\"inputs\":[{\"label\":\"Stop requested\",\"shape\":[],\"elementType\":\"bool\",\"quantity\":\"dimensionless\"}],\"outputs\":[{\"label\":\"Stop accepted\",\"shape\":[],\"elementType\":\"bool\",\"quantity\":\"dimensionless\"}],\"params\":[],\"sampleTimeS\":0.1}"
              }
            ],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-native-stop-simulation/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:native-switch-case-actions",
      "type": "Block",
      "label": "Case action router",
      "properties": {
        "id": "native-switch-case-actions",
        "name": "Case action router",
        "kind": "studio",
        "summary": "Routes an integer mode to exactly one configured case flag or the final default flag, without fall-through.",
        "behavior": "Routes an integer mode to exactly one configured case flag or the final default flag, without fall-through. Outputs are held between accepted samples; numerical evaluation does not commit hidden state.",
        "ports": [
          {
            "name": "in0",
            "direction": "input",
            "unit": "—",
            "description": "Case; i32 scalar."
          },
          {
            "name": "out0",
            "direction": "output",
            "unit": "—",
            "description": "Case 0; bool scalar."
          },
          {
            "name": "out1",
            "direction": "output",
            "unit": "—",
            "description": "Case 1; bool scalar."
          },
          {
            "name": "out2",
            "direction": "output",
            "unit": "—",
            "description": "Case 2; bool scalar."
          },
          {
            "name": "out3",
            "direction": "output",
            "unit": "—",
            "description": "Default; bool scalar."
          }
        ],
        "parameters": [
          {
            "key": "sampleTimeS",
            "label": "Sample period",
            "unit": "s",
            "default": 1,
            "min": 0,
            "description": "Positive interval between accepted control samples. Outputs hold between these instants."
          },
          {
            "key": "params[0]",
            "label": "Case values",
            "unit": "—",
            "default": 0,
            "description": "Distinct 32-bit integers, one for each output; a default output is added."
          },
          {
            "key": "params[1]",
            "label": "Case values",
            "unit": "—",
            "default": 1,
            "description": "Distinct 32-bit integers, one for each output; a default output is added."
          },
          {
            "key": "params[2]",
            "label": "Case values",
            "unit": "—",
            "default": 2,
            "description": "Distinct 32-bit integers, one for each output; a default output is added."
          }
        ],
        "equations": [
          "case[i] = input = configuredCase[i]",
          "default = no configured case matches"
        ],
        "example": {
          "title": "Case action router worked example",
          "text": "Default editable example at the first accepted sample (t = 0 s). The output checks below are execution oracles for this example.",
          "url": "https://design.lemonergy.com/cosim.html?example=block-native-switch-case-actions",
          "label": "Open Studio example",
          "inputs": [
            {
              "port": "in0",
              "label": "Case",
              "value": 2,
              "unit": "—"
            }
          ],
          "checks": [
            {
              "port": "out0",
              "label": "Case 0",
              "atS": 0,
              "value": 0,
              "unit": "—",
              "tolerance": 1e-08
            },
            {
              "port": "out1",
              "label": "Case 1",
              "atS": 0,
              "value": 0,
              "unit": "—",
              "tolerance": 1e-08
            },
            {
              "port": "out2",
              "label": "Case 2",
              "atS": 0,
              "value": 1,
              "unit": "—",
              "tolerance": 1e-08
            },
            {
              "port": "out3",
              "label": "Default",
              "atS": 0,
              "value": 0,
              "unit": "—",
              "tolerance": 1e-08
            }
          ]
        },
        "limits": [
          "Control executes on an explicit sampled clock. Continuous states, history/delay kernels, residual equations, and event-source children are not supported.",
          "1–31 distinct signed 32-bit cases and one default branch. There is no fall-through."
        ],
        "references": [
          "control-dataflow"
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "caseIds": [
          "native-native-switch-case-actions"
        ],
        "exampleTraces": [
          {
            "id": "native-switch-case-actions",
            "url": "https://lemonergy.com/learn/glossary/api/traces/native-switch-case-actions.json?v=be8e3b1de373",
            "title": "Case action router recorded example",
            "exampleId": "block-native-switch-case-actions",
            "source": "Executed synthetic Lemonergy Studio example",
            "recordedOn": "2026-10-28",
            "points": 3,
            "channels": 4,
            "omittedChannels": 0,
            "interpolation": "step",
            "solver": {
              "method": "dormand-prince-45",
              "reason": "no-continuous-states"
            }
          }
        ],
        "type": "native-switch-case-actions",
        "implementationId": "native-switch-case-actions",
        "url": "https://lemonergy.com/learn/glossary/blocks/native-switch-case-actions/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/native-switch-case-actions/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=block-native-switch-case-actions"
          ]
        },
        "studioHelp": {
          "type": "native-switch-case-actions",
          "namespace": "signal",
          "slug": "signal-block-native-switch-case-actions",
          "canonicalSlug": "native-switch-case-actions",
          "existing": true,
          "dynamic": false,
          "scene": {
            "title": "Case action router",
            "label": "Case action router",
            "summary": "Routes an integer mode to exactly one configured case flag or the final default flag, without fall-through.",
            "details": [
              "Block type: native-switch-case-actions.",
              "1 declared input and 4 declared outputs in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "condition → branch",
              "label": "Selection and control",
              "caption": "Routes an integer mode to exactly one configured case flag or the final default flag, without fall-through."
            },
            "inputs": [
              {
                "label": "Case",
                "quantity": "dimensionless",
                "shape": [],
                "elementType": "i32",
                "id": "in0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "i32"
              }
            ],
            "outputs": [
              {
                "label": "Case 0",
                "quantity": "dimensionless",
                "shape": [],
                "elementType": "bool",
                "id": "out0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "bool"
              },
              {
                "label": "Case 1",
                "quantity": "dimensionless",
                "shape": [],
                "elementType": "bool",
                "id": "out1",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "bool"
              },
              {
                "label": "Case 2",
                "quantity": "dimensionless",
                "shape": [],
                "elementType": "bool",
                "id": "out2",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "bool"
              },
              {
                "label": "Default",
                "quantity": "dimensionless",
                "shape": [],
                "elementType": "bool",
                "id": "out3",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "bool"
              }
            ],
            "parameters": [
              {
                "id": "config",
                "label": "Configuration",
                "unit": "",
                "value": "{\"sampleTimeS\":1,\"params\":[0,1,2],\"tables\":[]}"
              }
            ],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-native-switch-case-actions/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:native-truth-table",
      "type": "Block",
      "label": "Truth table",
      "properties": {
        "id": "native-truth-table",
        "name": "Truth table",
        "kind": "studio",
        "summary": "Uses a Boolean input pattern to select a configured truth-table result.",
        "behavior": "address = Σᵢ inputᵢ × 2ⁱ; y = table[address]. The worked example connects this operation to signals in Lemonergy Studio.",
        "ports": [
          {
            "name": "in0",
            "direction": "input",
            "unit": "1",
            "description": "Inputs; bool 2 array.",
            "shape": [
              2
            ],
            "elementType": "bool"
          },
          {
            "name": "out0",
            "direction": "output",
            "unit": "1",
            "description": "Result; bool scalar.",
            "shape": [],
            "elementType": "bool"
          }
        ],
        "parameters": [
          {
            "key": "tables[0]",
            "label": "Truth table",
            "unit": "1",
            "default": [
              0,
              1,
              1,
              0
            ],
            "description": "Input 0 is least significant address bit. One Boolean output per address."
          }
        ],
        "equations": [
          "address = Σᵢ inputᵢ × 2ⁱ; y = table[address]"
        ],
        "example": {
          "title": "Truth table — worked example",
          "text": "Inputs = [1,0]. Result at 0 s = 1.",
          "url": "https://design.lemonergy.com/cosim.html?example=block-native-truth-table",
          "label": "Open Studio example",
          "inputs": [
            {
              "port": "in0",
              "label": "Inputs",
              "value": [
                1,
                0
              ],
              "unit": "1"
            }
          ],
          "checks": [
            {
              "port": "out0",
              "label": "Result",
              "atS": 0,
              "value": 1,
              "unit": "1",
              "tolerance": 1e-08
            }
          ]
        },
        "limits": [
          "At most10 Boolean address bits and one Boolean output table; input0 is least significant.",
          "Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed."
        ],
        "references": [],
        "referenceNote": "This software operation and its numerical conventions are defined by the public contract and worked example; no external research result is claimed.",
        "caseIds": [
          "native-native-truth-table"
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "exampleTraces": [
          {
            "id": "native-truth-table",
            "url": "https://lemonergy.com/learn/glossary/api/traces/native-truth-table.json?v=589fb6916bff",
            "title": "Truth table recorded example",
            "exampleId": "block-native-truth-table",
            "source": "Executed synthetic Lemonergy Studio example",
            "recordedOn": "2026-10-28",
            "points": 2,
            "channels": 1,
            "omittedChannels": 0,
            "interpolation": "linear",
            "solver": {
              "method": "dormand-prince-45",
              "reason": "no-continuous-states"
            }
          }
        ],
        "type": "native-truth-table",
        "implementationId": "native-truth-table",
        "url": "https://lemonergy.com/learn/glossary/blocks/native-truth-table/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/native-truth-table/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=block-native-truth-table"
          ]
        },
        "studioHelp": {
          "type": "native-truth-table",
          "namespace": "signal",
          "slug": "signal-block-native-truth-table",
          "canonicalSlug": "native-truth-table",
          "existing": true,
          "dynamic": false,
          "scene": {
            "title": "Truth table",
            "label": "Truth table",
            "summary": "Uses a Boolean input pattern to select a configured truth-table result.",
            "details": [
              "Block type: native-truth-table.",
              "1 declared input and 1 declared output in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "input → condition → result",
              "label": "Truth table",
              "caption": "Uses a Boolean input pattern to select a configured truth-table result."
            },
            "inputs": [
              {
                "label": "Inputs",
                "shape": [
                  2
                ],
                "quantity": "dimensionless",
                "elementType": "bool",
                "id": "in0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Array 2",
                "elementLabel": "bool"
              }
            ],
            "outputs": [
              {
                "label": "Result",
                "shape": [],
                "quantity": "dimensionless",
                "elementType": "bool",
                "id": "out0",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "bool"
              }
            ],
            "parameters": [
              {
                "id": "config",
                "label": "Configuration",
                "unit": "",
                "value": "{\"inputs\":[{\"label\":\"Inputs\",\"shape\":[2],\"quantity\":\"dimensionless\",\"elementType\":\"bool\"}],\"outputs\":[{\"label\":\"Result\",\"shape\":[],\"quantity\":\"dimensionless\",\"elementType\":\"bool\"}],\"sampleTimeS\":0,\"params\":[],\"tables\":[[0,1,1,0]]}"
              }
            ],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-native-truth-table/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:pi-controller",
      "type": "Block",
      "label": "PI controller",
      "properties": {
        "id": "pi-controller",
        "kind": "studio",
        "name": "PI controller",
        "summary": "Discrete PI on setpoint minus measurement with output bounds; the integral freezes while the output sits at a bound (anti-windup).",
        "behavior": "Discrete PI on setpoint minus measurement with output bounds; the integral freezes while the output sits at a bound (anti-windup).",
        "documentationSlug": "signal-block-pi-controller",
        "referenceOnly": true,
        "ports": [
          {
            "name": "Setpoint",
            "direction": "input",
            "unit": "—",
            "description": "Number; Scalar; real. Received from a connected producer."
          },
          {
            "name": "Measurement",
            "direction": "input",
            "unit": "—",
            "description": "Number; Scalar; real. Received from a connected producer."
          },
          {
            "name": "Output",
            "direction": "output",
            "unit": "—",
            "description": "Number; Scalar; real. Produced for connected consumers."
          }
        ],
        "parameters": [
          {
            "key": "sampleTimeS",
            "label": "Sample time",
            "unit": "s",
            "default": "0.01",
            "description": "Declared authoring field: Sample time."
          },
          {
            "key": "inputQuantity",
            "label": "Setpoint and measurement quantity",
            "unit": "",
            "default": "dimensionless",
            "description": "Declared authoring field: Setpoint and measurement quantity."
          },
          {
            "key": "kp",
            "label": "Proportional gain",
            "unit": "",
            "default": "1",
            "description": "Declared authoring field: Proportional gain."
          },
          {
            "key": "ki",
            "label": "Integral gain",
            "unit": "1/s",
            "default": "0",
            "description": "Declared authoring field: Integral gain."
          },
          {
            "key": "min",
            "label": "Output minimum",
            "unit": "",
            "default": "-1",
            "description": "Declared authoring field: Output minimum."
          },
          {
            "key": "max",
            "label": "Output maximum",
            "unit": "",
            "default": "1",
            "description": "Declared authoring field: Output maximum."
          },
          {
            "key": "initialIntegral",
            "label": "Initial integral",
            "unit": "",
            "default": "0",
            "description": "Declared authoring field: Initial integral."
          }
        ],
        "equations": [],
        "example": {
          "title": "Use this authoring component",
          "text": "Choose this component in the Studio library and configure its declared interface. This reference describes the authoring contract; it does not claim a standalone numerical validation or a measured result.",
          "url": "https://design.lemonergy.com/cosim",
          "label": "Open Studio"
        },
        "limits": [
          "The symbolic diagram describes the component and its declared interface. It is not a solved circuit or simulated output.",
          "Configured parameters and model connections determine the result. Check the complete model before interpreting its outputs."
        ],
        "evidence": [
          "docs/glossary/studio-help-catalog.json"
        ],
        "caseIds": [],
        "sourceRepository": "battery-design",
        "sourceRevision": "0a28f1a0a75a0447903b868cbcc734133a77a847",
        "reviewed": "2026-10-30",
        "type": "pi-controller",
        "implementationId": "pi-controller",
        "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/",
        "sourceFile": "studio-help-catalog.json",
        "studioHelp": {
          "type": "pi-controller",
          "namespace": "signal",
          "slug": "signal-block-pi-controller",
          "canonicalSlug": "signal-block-pi-controller",
          "existing": false,
          "dynamic": false,
          "scene": {
            "title": "PI controller",
            "label": "PI controller",
            "summary": "Discrete PI on setpoint minus measurement with output bounds; the integral freezes while the output sits at a bound (anti-windup).",
            "details": [
              "Block type: pi-controller.",
              "2 declared inputs and 1 declared output in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "P + ∫ I",
              "label": "Sampled feedback control",
              "caption": "Discrete PI on setpoint minus measurement with output bounds; the integral freezes while the output sits at a bound (anti-windup)."
            },
            "inputs": [
              {
                "id": "in0",
                "label": "Setpoint",
                "quantity": "dimensionless",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              },
              {
                "id": "in1",
                "label": "Measurement",
                "quantity": "dimensionless",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              }
            ],
            "outputs": [
              {
                "id": "out0",
                "label": "Output",
                "quantity": "dimensionless",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              }
            ],
            "parameters": [
              {
                "id": "sampleTimeS",
                "label": "Sample time",
                "unit": "s",
                "value": "0.01"
              },
              {
                "id": "inputQuantity",
                "label": "Setpoint and measurement quantity",
                "unit": "",
                "value": "dimensionless"
              },
              {
                "id": "kp",
                "label": "Proportional gain",
                "unit": "",
                "value": "1"
              },
              {
                "id": "ki",
                "label": "Integral gain",
                "unit": "1/s",
                "value": "0"
              },
              {
                "id": "min",
                "label": "Output minimum",
                "unit": "",
                "value": "-1"
              },
              {
                "id": "max",
                "label": "Output maximum",
                "unit": "",
                "value": "1"
              },
              {
                "id": "initialIntegral",
                "label": "Initial integral",
                "unit": "",
                "value": "0"
              }
            ],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:select",
      "type": "Block",
      "label": "Select",
      "properties": {
        "id": "select",
        "kind": "studio",
        "name": "Select",
        "summary": "Passes the first value while the control is at least 0.5 and the second otherwise; both values carry the output quantity.",
        "behavior": "Passes the first value while the control is at least 0.5 and the second otherwise; both values carry the output quantity.",
        "documentationSlug": "signal-block-select",
        "referenceOnly": true,
        "ports": [
          {
            "name": "Control (0 or 1)",
            "direction": "input",
            "unit": "—",
            "description": "Number; Scalar; real. Received from a connected producer."
          },
          {
            "name": "When true",
            "direction": "input",
            "unit": "—",
            "description": "Number; Scalar; real. Received from a connected producer."
          },
          {
            "name": "When false",
            "direction": "input",
            "unit": "—",
            "description": "Number; Scalar; real. Received from a connected producer."
          },
          {
            "name": "Output",
            "direction": "output",
            "unit": "—",
            "description": "Number; Scalar; real. Produced for connected consumers."
          }
        ],
        "parameters": [],
        "equations": [],
        "example": {
          "title": "Use this authoring component",
          "text": "Choose this component in the Studio library and configure its declared interface. This reference describes the authoring contract; it does not claim a standalone numerical validation or a measured result.",
          "url": "https://design.lemonergy.com/cosim",
          "label": "Open Studio"
        },
        "limits": [
          "The symbolic diagram describes the component and its declared interface. It is not a solved circuit or simulated output.",
          "Configured parameters and model connections determine the result. Check the complete model before interpreting its outputs."
        ],
        "evidence": [
          "docs/glossary/studio-help-catalog.json"
        ],
        "caseIds": [],
        "sourceRepository": "battery-design",
        "sourceRevision": "0a28f1a0a75a0447903b868cbcc734133a77a847",
        "reviewed": "2026-10-30",
        "type": "select",
        "implementationId": "select",
        "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-select/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/signal-block-select/",
        "sourceFile": "studio-help-catalog.json",
        "studioHelp": {
          "type": "select",
          "namespace": "signal",
          "slug": "signal-block-select",
          "canonicalSlug": "signal-block-select",
          "existing": false,
          "dynamic": false,
          "scene": {
            "title": "Select",
            "label": "Select",
            "summary": "Passes the first value while the control is at least 0.5 and the second otherwise; both values carry the output quantity.",
            "details": [
              "Block type: select.",
              "3 declared inputs and 1 declared output in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "condition → branch",
              "label": "Selection and control",
              "caption": "Passes the first value while the control is at least 0.5 and the second otherwise; both values carry the output quantity."
            },
            "inputs": [
              {
                "id": "in0",
                "label": "Control (0 or 1)",
                "quantity": "dimensionless",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              },
              {
                "id": "in1",
                "label": "When true",
                "quantity": "dimensionless",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              },
              {
                "id": "in2",
                "label": "When false",
                "quantity": "dimensionless",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              }
            ],
            "outputs": [
              {
                "id": "out0",
                "label": "Output",
                "quantity": "dimensionless",
                "unit": "—",
                "unitDeclared": true,
                "fields": [],
                "quantityLabel": "Number",
                "shapeLabel": "Scalar",
                "elementLabel": "real"
              }
            ],
            "parameters": [],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-select/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:variant-end",
      "type": "Block",
      "label": "Variant branch end",
      "properties": {
        "id": "variant-end",
        "name": "Variant branch end",
        "kind": "studio",
        "summary": "Selects the active input at the end of a compile-time branch region.",
        "behavior": "Keeps one input path at the end of a statically selected branch region.",
        "ports": [
          {
            "name": "in0",
            "direction": "input",
            "unit": "1",
            "description": "Branch 0; real signal.",
            "shape": [],
            "elementType": "real"
          },
          {
            "name": "in1",
            "direction": "input",
            "unit": "1",
            "description": "Branch 1; real signal.",
            "shape": [],
            "elementType": "real"
          },
          {
            "name": "out0",
            "direction": "output",
            "unit": "1",
            "description": "Branch 0; real signal.",
            "shape": [],
            "elementType": "real"
          }
        ],
        "parameters": [
          {
            "key": "selected",
            "label": "selected",
            "unit": "1",
            "default": 0,
            "description": "Explicit selected in the worked model."
          },
          {
            "key": "count",
            "label": "count",
            "unit": "1",
            "default": 2,
            "description": "Explicit count in the worked model."
          },
          {
            "key": "signal.quantity",
            "label": "signal quantity",
            "unit": "1",
            "default": "dimensionless",
            "description": "Explicit signal quantity in the worked model."
          },
          {
            "key": "signal.shape",
            "label": "signal shape",
            "unit": "1",
            "default": [],
            "description": "Explicit signal shape in the worked model."
          },
          {
            "key": "signal.elementType",
            "label": "signal element Type",
            "unit": "1",
            "default": "real",
            "description": "Explicit signal elementType in the worked model."
          }
        ],
        "equations": [
          "y = configured active input"
        ],
        "example": {
          "title": "Variant branch end — executable model",
          "text": "The first input3 is selected and doubled downstream to6.",
          "url": "https://design.lemonergy.com/cosim.html?example=routing-variant-end",
          "label": "Open Studio example",
          "inputs": [],
          "checks": [
            {
              "port": "Result",
              "label": "Result",
              "atS": 0.2,
              "value": 6,
              "unit": "1",
              "tolerance": 1e-09
            }
          ]
        },
        "limits": [
          "Selection is configured before compilation; inactive paths are omitted rather than dynamically merged."
        ],
        "references": [],
        "referenceNote": "This compiler and software type contract is defined by the documented behavior and executable example; no external research result or full external API parity is claimed.",
        "caseIds": [
          "native-variant-end"
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "type": "variant-end",
        "implementationId": "variant-end",
        "url": "https://lemonergy.com/learn/glossary/blocks/variant-end/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/variant-end/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=routing-variant-end"
          ]
        },
        "studioHelp": {
          "type": "variant-end",
          "namespace": "signal",
          "slug": "signal-block-variant-end",
          "canonicalSlug": "variant-end",
          "existing": true,
          "dynamic": true,
          "scene": {
            "title": "Variant branch end",
            "label": "Variant branch end",
            "summary": "Selects the active input at the end of a compile-time branch region.",
            "details": [
              "Block type: variant-end.",
              "0 declared inputs and 0 declared outputs in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "condition → branch",
              "label": "Selection and control",
              "caption": "Selects the active input at the end of a compile-time branch region."
            },
            "inputs": [],
            "outputs": [],
            "parameters": [],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-variant-end/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:variant-sink",
      "type": "Block",
      "label": "Variant sink",
      "properties": {
        "id": "variant-sink",
        "name": "Variant sink",
        "kind": "studio",
        "summary": "Activates one output branch before execution; inactive branch consumers are omitted.",
        "behavior": "Only the selected output branch and its downstream consumers remain active in the compiled graph.",
        "ports": [
          {
            "name": "in0",
            "direction": "input",
            "unit": "1",
            "description": "Branch 0; real signal.",
            "shape": [],
            "elementType": "real"
          },
          {
            "name": "out0",
            "direction": "output",
            "unit": "1",
            "description": "Branch 0; real signal.",
            "shape": [],
            "elementType": "real"
          },
          {
            "name": "out1",
            "direction": "output",
            "unit": "1",
            "description": "Branch 1; real signal.",
            "shape": [],
            "elementType": "real"
          }
        ],
        "parameters": [
          {
            "key": "selected",
            "label": "selected",
            "unit": "1",
            "default": 0,
            "description": "Explicit selected in the worked model."
          },
          {
            "key": "count",
            "label": "count",
            "unit": "1",
            "default": 2,
            "description": "Explicit count in the worked model."
          },
          {
            "key": "signal.quantity",
            "label": "signal quantity",
            "unit": "1",
            "default": "dimensionless",
            "description": "Explicit signal quantity in the worked model."
          },
          {
            "key": "signal.shape",
            "label": "signal shape",
            "unit": "1",
            "default": [],
            "description": "Explicit signal shape in the worked model."
          },
          {
            "key": "signal.elementType",
            "label": "signal element Type",
            "unit": "1",
            "default": "real",
            "description": "Explicit signal elementType in the worked model."
          }
        ],
        "equations": [
          "selected output = input; inactive consumers are excluded from execution"
        ],
        "example": {
          "title": "Variant sink — executable model",
          "text": "Input3 reaches the active gain2 and produces6. The inactive gain100 is absent from execution.",
          "url": "https://design.lemonergy.com/cosim.html?example=routing-variant-sink",
          "label": "Open Studio example",
          "inputs": [],
          "checks": [
            {
              "port": "Result",
              "label": "Result",
              "atS": 0.2,
              "value": 6,
              "unit": "1",
              "tolerance": 1e-09
            }
          ]
        },
        "limits": [
          "Selection is fixed before execution. This does not emit zeros to inactive branches."
        ],
        "references": [],
        "referenceNote": "This compiler and software type contract is defined by the documented behavior and executable example; no external research result or full external API parity is claimed.",
        "caseIds": [
          "native-variant-sink"
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "type": "variant-sink",
        "implementationId": "variant-sink",
        "url": "https://lemonergy.com/learn/glossary/blocks/variant-sink/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/variant-sink/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=routing-variant-sink"
          ]
        },
        "studioHelp": {
          "type": "variant-sink",
          "namespace": "signal",
          "slug": "signal-block-variant-sink",
          "canonicalSlug": "variant-sink",
          "existing": true,
          "dynamic": true,
          "scene": {
            "title": "Variant sink",
            "label": "Variant sink",
            "summary": "Activates one output branch before execution; inactive branch consumers are omitted.",
            "details": [
              "Block type: variant-sink.",
              "0 declared inputs and 0 declared outputs in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "condition → branch",
              "label": "Selection and control",
              "caption": "Activates one output branch before execution; inactive branch consumers are omitted."
            },
            "inputs": [],
            "outputs": [],
            "parameters": [],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-variant-sink/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:variant-source",
      "type": "Block",
      "label": "Variant source",
      "properties": {
        "id": "variant-source",
        "name": "Variant source",
        "kind": "studio",
        "summary": "Selects an input branch before execution and removes unused inactive producers.",
        "behavior": "One configured input remains in the compiled graph. Inactive producers are removed only when no live consumer still uses them.",
        "ports": [
          {
            "name": "in0",
            "direction": "input",
            "unit": "1",
            "description": "Branch 0; real signal.",
            "shape": [],
            "elementType": "real"
          },
          {
            "name": "in1",
            "direction": "input",
            "unit": "1",
            "description": "Branch 1; real signal.",
            "shape": [],
            "elementType": "real"
          },
          {
            "name": "out0",
            "direction": "output",
            "unit": "1",
            "description": "Branch 0; real signal.",
            "shape": [],
            "elementType": "real"
          }
        ],
        "parameters": [
          {
            "key": "selected",
            "label": "selected",
            "unit": "1",
            "default": 0,
            "description": "Explicit selected in the worked model."
          },
          {
            "key": "count",
            "label": "count",
            "unit": "1",
            "default": 2,
            "description": "Explicit count in the worked model."
          },
          {
            "key": "signal.quantity",
            "label": "signal quantity",
            "unit": "1",
            "default": "dimensionless",
            "description": "Explicit signal quantity in the worked model."
          },
          {
            "key": "signal.shape",
            "label": "signal shape",
            "unit": "1",
            "default": [],
            "description": "Explicit signal shape in the worked model."
          },
          {
            "key": "signal.elementType",
            "label": "signal element Type",
            "unit": "1",
            "default": "real",
            "description": "Explicit signal elementType in the worked model."
          }
        ],
        "equations": [
          "y = selected branch input"
        ],
        "example": {
          "title": "Variant source — executable model",
          "text": "Selecting the first source3 and applying gain2 produces6; selecting source7 produces14.",
          "url": "https://design.lemonergy.com/cosim.html?example=routing-variant-source",
          "label": "Open Studio example",
          "inputs": [],
          "checks": [
            {
              "port": "Result",
              "label": "Result",
              "atS": 0.2,
              "value": 6,
              "unit": "1",
              "tolerance": 1e-09
            }
          ]
        },
        "limits": [
          "Static zero-based selection among1–32 fixed typed branches. Shared live producers are preserved."
        ],
        "references": [],
        "referenceNote": "This compiler and software type contract is defined by the documented behavior and executable example; no external research result or full external API parity is claimed.",
        "caseIds": [
          "native-variant-source"
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "type": "variant-source",
        "implementationId": "variant-source",
        "url": "https://lemonergy.com/learn/glossary/blocks/variant-source/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/variant-source/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=routing-variant-source"
          ]
        },
        "studioHelp": {
          "type": "variant-source",
          "namespace": "signal",
          "slug": "signal-block-variant-source",
          "canonicalSlug": "variant-source",
          "existing": true,
          "dynamic": true,
          "scene": {
            "title": "Variant source",
            "label": "Variant source",
            "summary": "Selects an input branch before execution and removes unused inactive producers.",
            "details": [
              "Block type: variant-source.",
              "0 declared inputs and 0 declared outputs in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "condition → branch",
              "label": "Selection and control",
              "caption": "Selects an input branch before execution and removes unused inactive producers."
            },
            "inputs": [],
            "outputs": [],
            "parameters": [],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-variant-source/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:variant-start",
      "type": "Block",
      "label": "Variant branch start",
      "properties": {
        "id": "variant-start",
        "name": "Variant branch start",
        "kind": "studio",
        "summary": "Starts a statically selected output branch with inactive-branch elimination.",
        "behavior": "Starts a statically selected branch region by activating one output path.",
        "ports": [
          {
            "name": "in0",
            "direction": "input",
            "unit": "1",
            "description": "Branch 0; real signal.",
            "shape": [],
            "elementType": "real"
          },
          {
            "name": "out0",
            "direction": "output",
            "unit": "1",
            "description": "Branch 0; real signal.",
            "shape": [],
            "elementType": "real"
          },
          {
            "name": "out1",
            "direction": "output",
            "unit": "1",
            "description": "Branch 1; real signal.",
            "shape": [],
            "elementType": "real"
          }
        ],
        "parameters": [
          {
            "key": "selected",
            "label": "selected",
            "unit": "1",
            "default": 0,
            "description": "Explicit selected in the worked model."
          },
          {
            "key": "count",
            "label": "count",
            "unit": "1",
            "default": 2,
            "description": "Explicit count in the worked model."
          },
          {
            "key": "signal.quantity",
            "label": "signal quantity",
            "unit": "1",
            "default": "dimensionless",
            "description": "Explicit signal quantity in the worked model."
          },
          {
            "key": "signal.shape",
            "label": "signal shape",
            "unit": "1",
            "default": [],
            "description": "Explicit signal shape in the worked model."
          },
          {
            "key": "signal.elementType",
            "label": "signal element Type",
            "unit": "1",
            "default": "real",
            "description": "Explicit signal elementType in the worked model."
          }
        ],
        "equations": [
          "active branch = configured selection"
        ],
        "example": {
          "title": "Variant branch start — executable model",
          "text": "The first branch takes input3 through gain2, producing6.",
          "url": "https://design.lemonergy.com/cosim.html?example=routing-variant-start",
          "label": "Open Studio example",
          "inputs": [],
          "checks": [
            {
              "port": "Result",
              "label": "Result",
              "atS": 0.2,
              "value": 6,
              "unit": "1",
              "tolerance": 1e-09
            }
          ]
        },
        "limits": [
          "Selected branch paths must remain consistent with the corresponding end selection. There are no symbolic condition expressions."
        ],
        "references": [],
        "referenceNote": "This compiler and software type contract is defined by the documented behavior and executable example; no external research result or full external API parity is claimed.",
        "caseIds": [
          "native-variant-start"
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "type": "variant-start",
        "implementationId": "variant-start",
        "url": "https://lemonergy.com/learn/glossary/blocks/variant-start/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/variant-start/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=routing-variant-start"
          ]
        },
        "studioHelp": {
          "type": "variant-start",
          "namespace": "signal",
          "slug": "signal-block-variant-start",
          "canonicalSlug": "variant-start",
          "existing": true,
          "dynamic": true,
          "scene": {
            "title": "Variant branch start",
            "label": "Variant branch start",
            "summary": "Starts a statically selected output branch with inactive-branch elimination.",
            "details": [
              "Block type: variant-start.",
              "0 declared inputs and 0 declared outputs in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "condition → branch",
              "label": "Selection and control",
              "caption": "Starts a statically selected output branch with inactive-branch elimination."
            },
            "inputs": [],
            "outputs": [],
            "parameters": [],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-variant-start/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:variant-subsystem",
      "type": "Block",
      "label": "Variant submodel",
      "properties": {
        "id": "variant-subsystem",
        "name": "Variant submodel",
        "kind": "studio",
        "summary": "Selects one compatible submodel definition before compilation.",
        "behavior": "Only the selected compatible definition is expanded into the execution model. The authoring model retains every choice.",
        "ports": [
          {
            "name": "u",
            "direction": "input",
            "unit": "1",
            "description": "Input; real signal.",
            "shape": [],
            "elementType": "real"
          },
          {
            "name": "y",
            "direction": "output",
            "unit": "1",
            "description": "Output; real signal.",
            "shape": [],
            "elementType": "real"
          }
        ],
        "parameters": [
          {
            "key": "selected",
            "label": "selected",
            "unit": "1",
            "default": 0,
            "description": "Explicit selected in the worked model."
          },
          {
            "key": "choices",
            "label": "choices",
            "unit": "1",
            "default": [
              {
                "definition": "double",
                "version": "1",
                "parameters": {}
              },
              {
                "definition": "triple",
                "version": "1",
                "parameters": {}
              }
            ],
            "description": "Explicit choices in the worked model."
          }
        ],
        "equations": [
          "execution model = selected definition with its own configured parameters"
        ],
        "example": {
          "title": "Variant submodel — executable model",
          "text": "A3-unit input enters the selected doubling model and produces6. Selecting the tripling model in a new run produces9.",
          "url": "https://design.lemonergy.com/cosim.html?example=routing-variant-subsystem",
          "label": "Open Studio example",
          "inputs": [],
          "checks": [
            {
              "port": "Result",
              "label": "Result",
              "atS": 0.2,
              "value": 6,
              "unit": "1",
              "tolerance": 1e-09
            }
          ]
        },
        "limits": [
          "Selection is fixed before the run. Choices must have identical named interfaces; arbitrary symbolic activation expressions and runtime switching are not supported."
        ],
        "references": [],
        "referenceNote": "This compiler and software type contract is defined by the documented behavior and executable example; no external research result or full external API parity is claimed.",
        "caseIds": [
          "native-variant-subsystem"
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "type": "variant-subsystem",
        "implementationId": "variant-subsystem",
        "url": "https://lemonergy.com/learn/glossary/blocks/variant-subsystem/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/variant-subsystem/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=routing-variant-subsystem"
          ]
        },
        "studioHelp": {
          "type": "variant-subsystem",
          "namespace": "signal",
          "slug": "signal-block-variant-subsystem",
          "canonicalSlug": "variant-subsystem",
          "existing": true,
          "dynamic": true,
          "scene": {
            "title": "Variant submodel",
            "label": "Variant submodel",
            "summary": "Selects one compatible submodel definition before compilation.",
            "details": [
              "Block type: variant-subsystem.",
              "0 declared inputs and 0 declared outputs in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "condition → branch",
              "label": "Selection and control",
              "caption": "Selects one compatible submodel definition before compilation."
            },
            "inputs": [],
            "outputs": [],
            "parameters": [],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-variant-subsystem/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "block:vector-select",
      "type": "Block",
      "label": "Vector selector",
      "properties": {
        "id": "vector-select",
        "name": "Vector selector",
        "kind": "studio",
        "summary": "Selects a configured element from a real vector.",
        "behavior": "The zero-based element index is checked against the fixed vector dimension before execution.",
        "ports": [
          {
            "name": "vector",
            "direction": "input",
            "unit": "1",
            "description": "Vector; real signal.",
            "shape": [
              3
            ],
            "elementType": "real"
          },
          {
            "name": "element",
            "direction": "output",
            "unit": "1",
            "description": "Element 1; real signal.",
            "shape": [],
            "elementType": "real"
          }
        ],
        "parameters": [
          {
            "key": "n",
            "label": "Vector length",
            "unit": "1",
            "default": 3,
            "description": "Explicit n used by this worked model."
          },
          {
            "key": "index",
            "label": "Selected zero-based index",
            "unit": "1",
            "default": 1,
            "description": "Explicit index used by this worked model."
          },
          {
            "key": "quantity",
            "label": "Physical quantity",
            "unit": "1",
            "default": "dimensionless",
            "description": "Explicit quantity used by this worked model."
          }
        ],
        "equations": [
          "y = vector[index]"
        ],
        "example": {
          "title": "Connect scalar and vector blocks",
          "text": "A = 1; B = 2; C = 3. Result at 1 s = 24.",
          "url": "https://design.lemonergy.com/cosim.html?example=routing-vector-bridge",
          "label": "Open Studio example",
          "inputs": [
            {
              "port": "A",
              "label": "A",
              "value": 1,
              "unit": "1"
            },
            {
              "port": "B",
              "label": "B",
              "value": 2,
              "unit": "1"
            },
            {
              "port": "C",
              "label": "C",
              "value": 3,
              "unit": "1"
            }
          ],
          "checks": [
            {
              "port": "Result",
              "label": "Result",
              "atS": 1,
              "value": 24,
              "unit": "1",
              "tolerance": 1e-09
            }
          ]
        },
        "limits": [
          "The selected index is configured before the run; use other routing operations for dynamic selection."
        ],
        "references": [],
        "referenceNote": "This software operation is defined by its public contract and worked example; no external research result is claimed.",
        "caseIds": [
          "native-vector-select"
        ],
        "availability": {
          "status": "released",
          "label": "Available in Lemonergy Studio",
          "detail": "The bundled example is available in the production release verified on 28 October 2026. The parameters and examples here are synthetic teaching fixtures, not a characterized cell or a validated operating limit."
        },
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ],
        "sourceRepository": "Lemonergy Studio public contract",
        "sourceRevision": "verification-2026-10-27",
        "type": "vector-select",
        "implementationId": "vector-select",
        "url": "https://lemonergy.com/learn/glossary/blocks/vector-select/",
        "documentationUrl": "https://lemonergy.com/learn/glossary/blocks/vector-select/",
        "sourceFile": "block-library.json",
        "reviewed": "2026-10-27",
        "releaseEvidence": {
          "environment": "production",
          "status": "verified",
          "revision": "e76cadfc203e15eb41f3478d8b1044a5b851953d",
          "verifiedOn": "2026-10-28",
          "exampleUrls": [
            "https://design.lemonergy.com/cosim.html?example=routing-vector-bridge"
          ]
        },
        "studioHelp": {
          "type": "vector-select",
          "namespace": "signal",
          "slug": "signal-block-vector-select",
          "canonicalSlug": "vector-select",
          "existing": true,
          "dynamic": true,
          "scene": {
            "title": "Vector selector",
            "label": "Vector selector",
            "summary": "Select one scalar by index.",
            "details": [
              "Block type: vector-select.",
              "0 declared inputs and 0 declared outputs in this model.",
              "Arrows show the direction of signal data. They are not conserving electrical, thermal or mechanical connections."
            ],
            "operation": {
              "kind": "control",
              "symbol": "condition → branch",
              "label": "Selection and control",
              "caption": "Select one scalar by index."
            },
            "inputs": [],
            "outputs": [],
            "parameters": [],
            "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-vector-select/",
            "related": [
              {
                "label": "Compare",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-compare/"
              },
              {
                "label": "Boolean latch",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-boolean-latch/"
              },
              {
                "label": "Pi controller",
                "url": "https://lemonergy.com/learn/glossary/blocks/signal-block-pi-controller/"
              }
            ],
            "selected": null,
            "connections": []
          }
        }
      }
    },
    {
      "id": "workflow:native-native-delay",
      "type": "Workflow",
      "label": "Sample delay — worked example",
      "properties": {
        "id": "native-native-delay",
        "title": "Sample delay — worked example",
        "kind": "studio",
        "summary": "Returns an input from a configured number of sample ticks earlier.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Value = 5. Delayed at 0 s = 0.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-delay",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-discrete-integrator",
      "type": "Workflow",
      "label": "Discrete integrator — worked example",
      "properties": {
        "id": "native-native-discrete-integrator",
        "title": "Discrete integrator — worked example",
        "kind": "studio",
        "summary": "Accumulates a signal over elapsed sample intervals with optional output bounds.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Value = 2. Integral at 1 s = 2.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Elapsed-time rectangular integration with configured gain, initial value and bounds; zero elapsed duration at initialization. Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-discrete-integrator",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-discrete-derivative",
      "type": "Workflow",
      "label": "Discrete derivative — worked example",
      "properties": {
        "id": "native-native-discrete-derivative",
        "title": "Discrete derivative — worked example",
        "kind": "studio",
        "summary": "Estimates a rate of change from successive samples and their elapsed time.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Value = 2. Derivative at 0 s = 0.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Backward difference at configured ticks; initialization output zero. Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-discrete-derivative",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-discrete-filter",
      "type": "Workflow",
      "label": "Discrete transfer function — worked example",
      "properties": {
        "id": "native-native-discrete-filter",
        "title": "Discrete transfer function — worked example",
        "kind": "studio",
        "summary": "Applies a causal discrete transfer function with separate input and output histories.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Value = 2. Filtered at 0 s = 1.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-discrete-filter",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-fir-filter",
      "type": "Workflow",
      "label": "FIR filter — worked example",
      "properties": {
        "id": "native-native-fir-filter",
        "title": "FIR filter — worked example",
        "kind": "studio",
        "summary": "Applies a finite set of weighted current and previous input samples.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Value = 4. Filtered at 0 s = 1.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-fir-filter",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-resettable-delay",
      "type": "Workflow",
      "label": "Resettable sample delay — worked example",
      "properties": {
        "id": "native-native-resettable-delay",
        "title": "Resettable sample delay — worked example",
        "kind": "studio",
        "summary": "Returns the previous sample or resets its stored value on a Boolean command.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Value = 5; Reset = 1. Delayed at 0 s = 2.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-resettable-delay",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-variable-delay",
      "type": "Workflow",
      "label": "Variable integer delay — worked example",
      "properties": {
        "id": "native-native-variable-delay",
        "title": "Variable integer delay — worked example",
        "kind": "studio",
        "summary": "Selects an input from a connected number of previous sample ticks.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Value = 5; Delay samples = 0. Delayed at 0 s = 5.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-variable-delay",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-change",
      "type": "Workflow",
      "label": "Detect change — worked example",
      "properties": {
        "id": "native-native-change",
        "title": "Detect change — worked example",
        "kind": "studio",
        "summary": "Reports whether the input changed since its previous sample.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Value = 2. Detected at 0 s = 1.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-change",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-increase",
      "type": "Workflow",
      "label": "Detect increase — worked example",
      "properties": {
        "id": "native-native-increase",
        "title": "Detect increase — worked example",
        "kind": "studio",
        "summary": "Reports whether the input increased since its previous sample.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Value = 2. Detected at 0 s = 1.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-increase",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-decrease",
      "type": "Workflow",
      "label": "Detect decrease — worked example",
      "properties": {
        "id": "native-native-decrease",
        "title": "Detect decrease — worked example",
        "kind": "studio",
        "summary": "Reports whether the input decreased since its previous sample.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Value = 1. Detected at 0 s = 1.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-decrease",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-rising-edge",
      "type": "Workflow",
      "label": "Detect rising edge — worked example",
      "properties": {
        "id": "native-native-rising-edge",
        "title": "Detect rising edge — worked example",
        "kind": "studio",
        "summary": "Reports a Boolean transition from false to true.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Value = 1. Detected at 0 s = 1.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-rising-edge",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-falling-edge",
      "type": "Workflow",
      "label": "Detect falling edge — worked example",
      "properties": {
        "id": "native-native-falling-edge",
        "title": "Detect falling edge — worked example",
        "kind": "studio",
        "summary": "Reports a Boolean transition from true to false.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Value = 0. Detected at 0 s = 1.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-falling-edge",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-running-minmax",
      "type": "Workflow",
      "label": "Running minimum and maximum — worked example",
      "properties": {
        "id": "native-native-running-minmax",
        "title": "Running minimum and maximum — worked example",
        "kind": "studio",
        "summary": "Tracks the smallest and largest observed values for each input element.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Value = 3. Minimum at 0 s = 3; Maximum at 0 s = 3.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-running-minmax",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-sample-hold",
      "type": "Workflow",
      "label": "Zero-order hold — worked example",
      "properties": {
        "id": "native-native-sample-hold",
        "title": "Zero-order hold — worked example",
        "kind": "studio",
        "summary": "Captures the input at sample ticks and holds it unchanged between them.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Value = 3. Held at 0 s = 3.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-sample-hold",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-discrete-state-space",
      "type": "Workflow",
      "label": "Discrete state space — worked example",
      "properties": {
        "id": "native-native-discrete-state-space",
        "title": "Discrete state space — worked example",
        "kind": "studio",
        "summary": "Advances a discrete linear state model and computes its output at each tick.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Input = 1. Output at 0 s = 0.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Real, dense, constant A/B/C/D; up to128 discrete states; difference-equation updates occur once per tick. Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-discrete-state-space",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-discrete-pid",
      "type": "Workflow",
      "label": "Discrete weighted PID — worked example",
      "properties": {
        "id": "native-native-discrete-pid",
        "title": "Discrete weighted PID — worked example",
        "kind": "studio",
        "summary": "Combines proportional, integral and filtered derivative control with setpoint weights and limits.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Setpoint = 1; Measurement = 0. Control at 1 s = 1.5.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-discrete-pid",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-sampled-rate-limiter",
      "type": "Workflow",
      "label": "Sampled rate limiter — worked example",
      "properties": {
        "id": "native-native-sampled-rate-limiter",
        "title": "Sampled rate limiter — worked example",
        "kind": "studio",
        "summary": "Limits how quickly each sampled output can rise or fall.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Value = 10. Limited at 1 s = 2.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Actual elapsed sample duration limits each output change. Ideal continuous slew tracking and continuous zero-crossing localization are not implemented. Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-sampled-rate-limiter",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-sampled-backlash",
      "type": "Workflow",
      "label": "Sampled backlash — worked example",
      "properties": {
        "id": "native-native-sampled-backlash",
        "title": "Sampled backlash — worked example",
        "kind": "studio",
        "summary": "Models a sampled mechanical deadband whose output retains its previous position inside the gap.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Value = 3. Output at 0 s = 2.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Backlash memory updates on configured sample instants. Continuous reversal localization is not implemented. Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-sampled-backlash",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-sampled-relay",
      "type": "Workflow",
      "label": "Sampled hysteresis relay — worked example",
      "properties": {
        "id": "native-native-sampled-relay",
        "title": "Sampled hysteresis relay — worked example",
        "kind": "studio",
        "summary": "Switches between two output levels using separate on and off thresholds.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Value = 3. Output at 0 s = 5.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Hysteresis commits on configured sample instants. Continuous threshold event localization is not implemented. Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-sampled-relay",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-conditional-hold",
      "type": "Workflow",
      "label": "Conditional hold — worked example",
      "properties": {
        "id": "native-native-conditional-hold",
        "title": "Conditional hold — worked example",
        "kind": "studio",
        "summary": "Updates a held value only while a Boolean enable input is true.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Value = 5; Enable = 0. Held at 0 s = 2.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-conditional-hold",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-difference",
      "type": "Workflow",
      "label": "Sample difference — worked example",
      "properties": {
        "id": "native-native-difference",
        "title": "Sample difference — worked example",
        "kind": "studio",
        "summary": "Subtracts the previous sample from the current sample without dividing by time.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Value = 3. Difference at 0 s = 2.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-difference",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-tapped-delay",
      "type": "Workflow",
      "label": "Tapped sample delay — worked example",
      "properties": {
        "id": "native-native-tapped-delay",
        "title": "Tapped sample delay — worked example",
        "kind": "studio",
        "summary": "Returns several previous samples simultaneously, newest first.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Value = 5. Previous samples at 0 s = [0,0,0].",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-tapped-delay",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-rise-positive",
      "type": "Workflow",
      "label": "Detect rise positive — worked example",
      "properties": {
        "id": "native-native-rise-positive",
        "title": "Detect rise positive — worked example",
        "kind": "studio",
        "summary": "Reports a sampled crossing from zero or negative into positive values.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Value = 1. Detected at 0 s = 1.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Sampled crossings at zero have explicit strict/non-strict variants. Continuous event localization, arbitrary crossing offset and event notification are not implemented. Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-rise-positive",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-fall-nonpositive",
      "type": "Workflow",
      "label": "Detect fall nonpositive — worked example",
      "properties": {
        "id": "native-native-fall-nonpositive",
        "title": "Detect fall nonpositive — worked example",
        "kind": "studio",
        "summary": "Reports a sampled crossing from positive into zero or negative values.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Value = 0. Detected at 0 s = 1.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-fall-nonpositive",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-rise-nonnegative",
      "type": "Workflow",
      "label": "Detect rise nonnegative — worked example",
      "properties": {
        "id": "native-native-rise-nonnegative",
        "title": "Detect rise nonnegative — worked example",
        "kind": "studio",
        "summary": "Reports a sampled crossing from negative into zero or positive values.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Value = 0. Detected at 0 s = 1.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-rise-nonnegative",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-fall-negative",
      "type": "Workflow",
      "label": "Detect fall negative — worked example",
      "properties": {
        "id": "native-native-fall-negative",
        "title": "Detect fall negative — worked example",
        "kind": "studio",
        "summary": "Reports a sampled crossing from zero or positive into negative values.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Value = -1. Detected at 0 s = 1.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-fall-negative",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-resettable-minmax",
      "type": "Workflow",
      "label": "Resettable running minimum and maximum — worked example",
      "properties": {
        "id": "native-native-resettable-minmax",
        "title": "Resettable running minimum and maximum — worked example",
        "kind": "studio",
        "summary": "Tracks running extrema and resets both to the current value on command.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Value = 3; Reset = 0. Minimum at 0 s = 3; Maximum at 0 s = 3.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Per-element running extrema with Boolean reset, evaluated at configured sample instants. Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-resettable-minmax",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-discrete-zero-pole",
      "type": "Workflow",
      "label": "Discrete pole-zero model — worked example",
      "properties": {
        "id": "native-native-discrete-zero-pole",
        "title": "Discrete pole-zero model — worked example",
        "kind": "studio",
        "summary": "Builds a causal discrete filter from real-coefficient poles, zeros and gain.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Input = 1. Output at 0 s = 0.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Proper real-coefficient transfer in z, conjugate-compatible roots, zero input/output histories. Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-discrete-zero-pole",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-discrete-first-order",
      "type": "Workflow",
      "label": "Discrete first-order filter — worked example",
      "properties": {
        "id": "native-native-discrete-first-order",
        "title": "Discrete first-order filter — worked example",
        "kind": "studio",
        "summary": "Smooths a signal with a stable first-order discrete filter.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Input = 2. Output at 0 s = 1.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Stable scalar pole parameter |a|<1; y[k]=(1-a)u[k]+a*y[k-1]. Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-discrete-first-order",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-discrete-lead-lag",
      "type": "Workflow",
      "label": "Discrete lead-lag filter — worked example",
      "properties": {
        "id": "native-native-discrete-lead-lag",
        "title": "Discrete lead-lag filter — worked example",
        "kind": "studio",
        "summary": "Applies a discrete lead-lag response derived from configured continuous time constants.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Input = 5. Output at 0 s = 3.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Bilinear-transform realization with nonnegative lead time, positive lag time and explicit sample time. Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-discrete-lead-lag",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-discrete-real-zero",
      "type": "Workflow",
      "label": "Discrete real-zero filter — worked example",
      "properties": {
        "id": "native-native-discrete-real-zero",
        "title": "Discrete real-zero filter — worked example",
        "kind": "studio",
        "summary": "Applies a gain and one real zero to successive input samples.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Input = 3. Output at 0 s = 6.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "gain*(u[k]-zero*u[k-1]), zero initial history. Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-discrete-real-zero",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-dynamic-rate-limiter",
      "type": "Workflow",
      "label": "Sampled dynamic rate limiter — worked example",
      "properties": {
        "id": "native-native-dynamic-rate-limiter",
        "title": "Sampled dynamic rate limiter — worked example",
        "kind": "studio",
        "summary": "Limits sampled output changes using connected rising and falling rate bounds.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Value = 10; Rising rate = 2; Falling rate magnitude = 3. Limited at 1 s = 2.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Connected rising/falling rates limit elapsed sample changes. Ideal continuous-rate dynamics are not implemented. Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-dynamic-rate-limiter",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-duty-pwm",
      "type": "Workflow",
      "label": "Sampled duty-controlled PWM — worked example",
      "properties": {
        "id": "native-native-duty-pwm",
        "title": "Sampled duty-controlled PWM — worked example",
        "kind": "studio",
        "summary": "Generates sampled pulse-width modulation from a connected duty ratio.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Duty ratio = 0.25. Pulse at 0 s = 1.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Connected duty ratio is compared with a configured carrier at exact sample instants. Carrier crossings between samples are not continuously localized. Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-duty-pwm",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-variable-pulse",
      "type": "Workflow",
      "label": "Sampled variable pulse generator — worked example",
      "properties": {
        "id": "native-native-variable-pulse",
        "title": "Sampled variable pulse generator — worked example",
        "kind": "studio",
        "summary": "Generates sampled pulses from connected period and duty inputs while preserving carrier phase.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Period = 0.5; Duty ratio = 0.25. Pulse at 0 s = 1.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Connected period and duty drive sampled elapsed-time phase accumulation without resetting phase. Continuous carrier crossings between samples are not localized. Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-variable-pulse",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-pid",
      "type": "Workflow",
      "label": "Continuous weighted PID — worked example",
      "properties": {
        "id": "native-native-pid",
        "title": "Continuous weighted PID — worked example",
        "kind": "studio",
        "summary": "Combines continuous proportional, integral and filtered derivative control with weights and limits.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Setpoint = 1; Measurement = 0. Control at 1 s = 1.5.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-pid",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-propagation-delay",
      "type": "Workflow",
      "label": "Boolean transport propagation delay — worked example",
      "properties": {
        "id": "native-native-propagation-delay",
        "title": "Boolean transport propagation delay — worked example",
        "kind": "studio",
        "summary": "Delays accepted Boolean transitions while preserving their transport order.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Input = 1. Delayed at 1 s = 1.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Accepted Boolean transitions use a fixed positive timestamped transport delay and propagated boundaries. Inertial pulse suppression and dynamic propagation delay are not implemented. Shapes and element types are explicit. Values must be finite; automatic reshaping and unit conversion are not performed.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-propagation-delay",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-enabled-submodel",
      "type": "Workflow",
      "label": "Enabled kernel worked example",
      "properties": {
        "id": "native-native-enabled-submodel",
        "title": "Enabled kernel worked example",
        "kind": "studio",
        "summary": "Runs one discrete or stateless child only while enabled; disabled samples retain child memory and held output.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Default editable example at the first accepted sample (t = 0 s). Child operation: discrete integrator. The output checks below are execution oracles for this example.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Control executes on an explicit sampled clock. Continuous states, history/delay kernels, residual equations, and event-source children are not supported. The wrapper contains one original computation operation; arbitrary multi-block submodels are not supported. A sampled child advances once per invocation using its own declared period. Repeated calls share the same outer timestamp and do not advance physical time. Reset-on-enable is optional; publishing the initial output while disabled does not itself reset child state.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-enabled-submodel",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-triggered-submodel",
      "type": "Workflow",
      "label": "Triggered kernel worked example",
      "properties": {
        "id": "native-native-triggered-submodel",
        "title": "Triggered kernel worked example",
        "kind": "studio",
        "summary": "Captures child inputs only on the configured Boolean edge, with explicit previous-trigger initialization.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Default editable example at the first accepted sample (t = 0 s). Child operation: adjustable gain. The output checks below are execution oracles for this example.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Control executes on an explicit sampled clock. Continuous states, history/delay kernels, residual equations, and event-source children are not supported. The wrapper contains one original computation operation; arbitrary multi-block submodels are not supported. A sampled child advances once per invocation using its own declared period. Repeated calls share the same outer timestamp and do not advance physical time. Boolean edges are detected only at the declared sample instants. Pulses entirely between samples are not captured.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-triggered-submodel",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-enabled-triggered-submodel",
      "type": "Workflow",
      "label": "Enabled and triggered kernel worked example",
      "properties": {
        "id": "native-native-enabled-triggered-submodel",
        "title": "Enabled and triggered kernel worked example",
        "kind": "studio",
        "summary": "Tracks every trigger edge, including while disabled, and executes only enabled edges; disabled edges are never replayed.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Default editable example at the first accepted sample (t = 0 s). Child operation: discrete integrator. The output checks below are execution oracles for this example.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Control executes on an explicit sampled clock. Continuous states, history/delay kernels, residual equations, and event-source children are not supported. The wrapper contains one original computation operation; arbitrary multi-block submodels are not supported. A sampled child advances once per invocation using its own declared period. Repeated calls share the same outer timestamp and do not advance physical time. A trigger edge seen while disabled is consumed and is not replayed when enable becomes true.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-enabled-triggered-submodel",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-resettable-submodel",
      "type": "Workflow",
      "label": "Resettable kernel worked example",
      "properties": {
        "id": "native-native-resettable-submodel",
        "title": "Resettable kernel worked example",
        "kind": "studio",
        "summary": "Restores the child initial memory before executing on a reset edge. Other samples execute normally.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Default editable example at the first accepted sample (t = 0 s). Child operation: discrete integrator. The output checks below are execution oracles for this example.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Control executes on an explicit sampled clock. Continuous states, history/delay kernels, residual equations, and event-source children are not supported. The wrapper contains one original computation operation; arbitrary multi-block submodels are not supported. A sampled child advances once per invocation using its own declared period. Repeated calls share the same outer timestamp and do not advance physical time. A sustained reset level does not repeatedly reset the child; select rising, falling, or either edge.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-resettable-submodel",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-function-call-submodel",
      "type": "Workflow",
      "label": "Counted kernel invocation worked example",
      "properties": {
        "id": "native-native-function-call-submodel",
        "title": "Counted kernel invocation worked example",
        "kind": "studio",
        "summary": "Executes one child the requested number of times at the accepted sample timestamp; zero calls retain memory and output.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Default editable example at the first accepted sample (t = 0 s). Child operation: discrete integrator. The output checks below are execution oracles for this example.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Control executes on an explicit sampled clock. Continuous states, history/delay kernels, residual equations, and event-source children are not supported. The wrapper contains one original computation operation; arbitrary multi-block submodels are not supported. A sampled child advances once per invocation using its own declared period. Repeated calls share the same outer timestamp and do not advance physical time. Explicit connected counts replace a global function-call namespace. Every repeated call receives the same current inputs.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-function-call-submodel",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-for-each-submodel",
      "type": "Workflow",
      "label": "Independent element kernels worked example",
      "properties": {
        "id": "native-native-for-each-submodel",
        "title": "Independent element kernels worked example",
        "kind": "studio",
        "summary": "Runs one scalar child instance per vector element, with fixed shape and isolated memory for every element.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Default editable example at the first accepted sample (t = 0 s). Child operation: discrete integrator. The output checks below are execution oracles for this example.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Control executes on an explicit sampled clock. Continuous states, history/delay kernels, residual equations, and event-source children are not supported. The wrapper contains one original computation operation; arbitrary multi-block submodels are not supported. A sampled child advances once per invocation using its own declared period. Repeated calls share the same outer timestamp and do not advance physical time. The child has one scalar input and one scalar output; the outer vector length is fixed at 1–256 elements.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-for-each-submodel",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-for-iterator-submodel",
      "type": "Workflow",
      "label": "Bounded for iterator worked example",
      "properties": {
        "id": "native-native-for-iterator-submodel",
        "title": "Bounded for iterator worked example",
        "kind": "studio",
        "summary": "Processes the requested prefix of an input vector through one scalar child, at a single sample time.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Default editable example at the first accepted sample (t = 0 s). Child operation: discrete integrator. The output checks below are execution oracles for this example.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Control executes on an explicit sampled clock. Continuous states, history/delay kernels, residual equations, and event-source children are not supported. The wrapper contains one original computation operation; arbitrary multi-block submodels are not supported. A sampled child advances once per invocation using its own declared period. Repeated calls share the same outer timestamp and do not advance physical time. The child has one scalar input and one scalar output. Only the requested prefix of the fixed input vector is processed.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-for-iterator-submodel",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-while-iterator-submodel",
      "type": "Workflow",
      "label": "Bounded while iterator worked example",
      "properties": {
        "id": "native-native-while-iterator-submodel",
        "title": "Bounded while iterator worked example",
        "kind": "studio",
        "summary": "Feeds each child result back as its next input, testing the condition before each call. A nonterminating loop stops without committing state.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Default editable example at the first accepted sample (t = 0 s). Child operation: adjustable gain. The output checks below are execution oracles for this example.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Control executes on an explicit sampled clock. Continuous states, history/delay kernels, residual equations, and event-source children are not supported. The wrapper contains one original computation operation; arbitrary multi-block submodels are not supported. A sampled child advances once per invocation using its own declared period. Repeated calls share the same outer timestamp and do not advance physical time. The child has matching real scalar input/output. At most 256 calls are allowed; nontermination raises a run error without committing a partial result.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-while-iterator-submodel",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-action-submodel",
      "type": "Workflow",
      "label": "Conditional action kernel worked example",
      "properties": {
        "id": "native-native-action-submodel",
        "title": "Conditional action kernel worked example",
        "kind": "studio",
        "summary": "Executes a child on a true action flag and holds its state and output on inactive samples.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Default editable example at the first accepted sample (t = 0 s). Child operation: bias. The output checks below are execution oracles for this example.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Control executes on an explicit sampled clock. Continuous states, history/delay kernels, residual equations, and event-source children are not supported. The wrapper contains one original computation operation; arbitrary multi-block submodels are not supported. A sampled child advances once per invocation using its own declared period. Repeated calls share the same outer timestamp and do not advance physical time. A Boolean action flag controls one child. This is not an arbitrary multi-block action subsystem.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-action-submodel",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-if-actions",
      "type": "Workflow",
      "label": "Comparison action router worked example",
      "properties": {
        "id": "native-native-if-actions",
        "title": "Comparison action router worked example",
        "kind": "studio",
        "summary": "Produces exactly one below/equal/above action flag for a configured threshold at each sample.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Default editable example at the first accepted sample (t = 0 s). The output checks below are execution oracles for this example.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Control executes on an explicit sampled clock. Continuous states, history/delay kernels, residual equations, and event-source children are not supported. One real threshold with below/equal/above branches; arbitrary logical expression parsing is not supplied.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-if-actions",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-switch-case-actions",
      "type": "Workflow",
      "label": "Case action router worked example",
      "properties": {
        "id": "native-native-switch-case-actions",
        "title": "Case action router worked example",
        "kind": "studio",
        "summary": "Routes an integer mode to exactly one configured case flag or the final default flag, without fall-through.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Default editable example at the first accepted sample (t = 0 s). The output checks below are execution oracles for this example.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Control executes on an explicit sampled clock. Continuous states, history/delay kernels, residual equations, and event-source children are not supported. 1–31 distinct signed 32-bit cases and one default branch. There is no fall-through.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-switch-case-actions",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-call-generator",
      "type": "Workflow",
      "label": "Sampled invocation generator worked example",
      "properties": {
        "id": "native-native-call-generator",
        "title": "Sampled invocation generator worked example",
        "kind": "studio",
        "summary": "Emits a bounded call count on enabled sample hits, after an integer sample offset; missed disabled hits are not replayed.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Default editable example at the first accepted sample (t = 0 s). The output checks below are execution oracles for this example.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Control executes on an explicit sampled clock. Continuous states, history/delay kernels, residual equations, and event-source children are not supported. Calls are explicit unsigned counts at accepted sample hits, not a global event bus. Disabled hits are not replayed. Total count overflow is rejected.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-call-generator",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-call-count-split",
      "type": "Workflow",
      "label": "Invocation count fan-out worked example",
      "properties": {
        "id": "native-native-call-count-split",
        "title": "Invocation count fan-out worked example",
        "kind": "studio",
        "summary": "Copies one accepted-sample call count to fixed typed branches. It does not impose side-effect order between independent downstream models.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Default editable example at the first accepted sample (t = 0 s). The output checks below are execution oracles for this example.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Control executes on an explicit sampled clock. Continuous states, history/delay kernels, residual equations, and event-source children are not supported. Fan-out does not impose execution or side-effect order on independent downstream models. Counts are limited to 0–256; 1–32 branches are supported.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-call-count-split",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-invocation-feedback",
      "type": "Workflow",
      "label": "Invocation feedback kernel worked example",
      "properties": {
        "id": "native-native-invocation-feedback",
        "title": "Invocation feedback kernel worked example",
        "kind": "studio",
        "summary": "Each call reads the previous held result, runs one child and commits its new result before the next call at the same timestamp.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Default editable example at the first accepted sample (t = 0 s). Child operation: bias. The output checks below are execution oracles for this example.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "Control executes on an explicit sampled clock. Continuous states, history/delay kernels, residual equations, and event-source children are not supported. The wrapper contains one original computation operation; arbitrary multi-block submodels are not supported. A sampled child advances once per invocation using its own declared period. Repeated calls share the same outer timestamp and do not advance physical time. One explicit child and one matching input/output port; no global function namespace or arbitrary feedback subgraph. At most 256 calls per sample.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-invocation-feedback",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-exclusive-merge",
      "type": "Workflow",
      "label": "Exclusive action merge worked example",
      "properties": {
        "id": "native-native-exclusive-merge",
        "title": "Exclusive action merge worked example",
        "kind": "studio",
        "summary": "Accepts one explicitly active branch at a sample, holds its prior value when none is active, and rejects competing writers.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Branch values are 2 and 5. Only branch 2 is active, so the accepted value is 5 and its owner index is 2.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "2–16 explicitly declared, identically typed branches. Boolean action flags supply ownership; ownership is not inferred from an arbitrary source subsystem. All inputs are validated even when inactive. Branches should share the declared sample clock. A conflict stops the run instead of choosing a writer by connection order.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-exclusive-merge",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-parameter-writer",
      "type": "Workflow",
      "label": "Scoped parameter writer worked example",
      "properties": {
        "id": "native-native-parameter-writer",
        "title": "Scoped parameter writer worked example",
        "kind": "studio",
        "summary": "Writes a stored parameter of one declared child at accepted samples, then executes that child with the updated parameter.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "Input 3 and an enabled gain write of 5 produce output 15. Later samples retain gain 5 when the write flag is false.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "One explicitly configured gain, bias, or discrete-integrator gain is writable. There is no arbitrary external-block lookup, global parameter mutation, or structural reconfiguration. Writes occur before the child executes at the accepted sample. Child memory persists across writes. A failed child evaluation commits neither the parameter nor child memory. The write port carries the numeric parameter value; no unit conversion is performed. A discrete child advances once per wrapper invocation using its declared period.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-parameter-writer",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-state-reader",
      "type": "Workflow",
      "label": "Scoped state reader worked example",
      "properties": {
        "id": "native-native-state-reader",
        "title": "Scoped state reader worked example",
        "kind": "studio",
        "summary": "Executes one declared discrete state-space child and records its actual internal state before and after each update.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "For A=0.5, B=1, C=2, D=3, initial state 4 and input 1, the model output is 11 and the internal state advances from 4 to 3.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "One declared discrete linear state-space child, with 1–128 real state coordinates. The reader owns and executes that child; it cannot inspect arbitrary foreign blocks. State outputs are explicit numeric coordinates, distinct from the model output. Continuous states, opaque kernel memory, and history buffers are not exposed.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-state-reader",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "workflow:native-native-state-writer",
      "type": "Workflow",
      "label": "Scoped state writer worked example",
      "properties": {
        "id": "native-native-state-writer",
        "title": "Scoped state writer worked example",
        "kind": "studio",
        "summary": "Replaces a declared discrete state-space child state on an enabled write, then evaluates output and advances that state at the accepted sample.",
        "steps": [
          "Review the interface, units and model limits.",
          "Open the Studio example and run its bundled model.",
          "Compare outputs with the numerical checks; change one input and run again."
        ],
        "example": "For A=0.5, B=1, C=2, D=3 and input 1, replacing the state with 10 before execution yields output 23 and next state 6.",
        "observe": "Inspect the output channels and checks on the block reference page.",
        "limits": "One declared discrete linear state-space child, with 1–128 real state coordinates. No arbitrary external-block, continuous-state, or history-buffer writes. Replacement is applied before output evaluation and state advancement. A failed or nonfinite update commits no partial state. Separate block instances own separate state.",
        "url": "https://design.lemonergy.com/cosim.html?example=block-native-state-writer",
        "label": "Open Studio example",
        "evidence": [
          "docs/glossary/native-block-verification.json"
        ]
      }
    },
    {
      "id": "topic:topic-data",
      "type": "Topic",
      "label": "Data, communication and electronics",
      "properties": {
        "id": "topic-data",
        "name": "Data, communication and electronics",
        "lede": "The control units, chips, protocols and file formats through which a battery is measured, controlled and logged.",
        "context": "Separate quantities from encoding and transport.",
        "example": "2500 in a log might mean 25.00 °C, 2.5 V or raw counts. Units and scale must accompany the value.",
        "lesson_url": "https://lemonergy.com/learn/fundamentals/battery-basics/",
        "lesson_label": "Open battery basics"
      }
    },
    {
      "id": "term:pid-controller",
      "type": "Term",
      "label": "PID controller",
      "properties": {
        "id": "pid-controller",
        "name": "PID controller",
        "abbr": "PID",
        "aka": [
          "proportional–integral–derivative controller",
          "PI controller"
        ],
        "section": "topic-data",
        "definition": "A feedback controller whose output is a weighted sum of the present error, its accumulated integral and its rate of change. It is the workhorse of battery systems — holding coolant temperature with a pump or compressor, regulating charger current and voltage — and often runs as PI only, without the derivative term.",
        "formula": "u = K_p·e + K_i·∫e dt + K_d·de/dt",
        "related": [
          "feedback-feedforward-control",
          "gain-scheduling",
          "thermal-management",
          "plant-model",
          "model-predictive-control"
        ],
        "example": {
          "title": "Separate three controller contributions",
          "text": "For an illustrative error e = 2, accumulated error 3 s and error slope −0.5/s, gains Kp = 1, Ki = 0.5/s and Kd = 0.2 s give u = 2 + 1.5 − 0.1 = 3.4. Output limits and anti-windup are separate design choices."
        },
        "url": "https://lemonergy.com/learn/glossary/pid-controller/",
        "mentions": [
          "charger",
          "refrigerant-loop"
        ]
      }
    },
    {
      "id": "term:plant-model",
      "type": "Term",
      "label": "Plant model",
      "properties": {
        "id": "plant-model",
        "name": "Plant model",
        "aka": [
          "system model"
        ],
        "section": "topic-data",
        "definition": "A model of the system being controlled — cells, pack, cooling loop, charger — as distinct from the controller itself. Engineers tune and verify BMS software against it in model-, software- and hardware-in-the-loop tests, so its fidelity, often an equivalent circuit model coupled to a thermal model, limits how much those tests prove.",
        "related": [
          "hil",
          "equivalent-circuit-model",
          "thermal-model",
          "digital-twin",
          "battery-emulator"
        ],
        "url": "https://lemonergy.com/learn/glossary/plant-model/",
        "mentions": [
          "charger",
          "bms",
          "firmware"
        ]
      }
    },
    {
      "id": "term:model-predictive-control",
      "type": "Term",
      "label": "Model predictive control",
      "properties": {
        "id": "model-predictive-control",
        "name": "Model predictive control",
        "abbr": "MPC",
        "section": "topic-data",
        "definition": "Control that uses a model to predict the system’s behaviour over a short horizon, chooses the input sequence that best meets a goal within constraints, applies the first step and repeats. In batteries it suits fast charging — the most current possible without breaching voltage or temperature limits or risking lithium plating — at a higher computing cost than PID.",
        "related": [
          "plant-model",
          "pid-controller",
          "fast-charging",
          "lithium-plating",
          "thermal-management",
          "equivalent-circuit-model"
        ],
        "url": "https://lemonergy.com/learn/glossary/model-predictive-control/",
        "mentions": []
      }
    },
    {
      "id": "term:thermal-management",
      "type": "Term",
      "label": "Thermal management",
      "properties": {
        "id": "thermal-management",
        "name": "Thermal management",
        "abbr": "TMS",
        "aka": [
          "battery thermal management system",
          "BTMS"
        ],
        "section": "topic-thermal",
        "definition": "Keeping cells in their comfortable range, roughly 15–35 °C, and within a few degrees of each other: liquid cooling plates, refrigerant plates or immersion for heat removal, and heaters or waste heat for warming before fast charging in the cold.",
        "related": [
          "cooling-plate",
          "thermal-interface-material",
          "operating-temperature",
          "heat-generation",
          "preconditioning",
          "temperature-sensor"
        ],
        "url": "https://lemonergy.com/learn/glossary/thermal-management/",
        "mentions": [
          "fast-charging"
        ]
      }
    },
    {
      "id": "term:heat-generation",
      "type": "Term",
      "label": "Heat generation",
      "properties": {
        "id": "heat-generation",
        "name": "Heat generation",
        "aka": [
          "Bernardi equation"
        ],
        "section": "topic-thermal",
        "definition": "The heat a cell produces in operation: an irreversible part equal to current times overpotential, and a reversible part from the entropy change, I·T·dE/dT. The Bernardi equation sums them and feeds every thermal model.",
        "formula": "q = I(V − E_OCV) + I·T·(dE/dT)",
        "unit": "W",
        "related": [
          "entropy-coefficient",
          "internal-resistance",
          "thermal-model",
          "thermal-management",
          "exothermic"
        ],
        "example": {
          "title": "Keep reversible and irreversible heat separate",
          "text": "With charging current +5 A and terminal voltage 0.10 V above OCV, the irreversible term is 0.50 W. At 300 K with dE/dT = +0.1 mV/K, the reversible contribution is +0.15 W, giving 0.65 W under this sign convention."
        },
        "url": "https://lemonergy.com/learn/glossary/heat-generation/",
        "mentions": [
          "overpotential"
        ]
      }
    }
  ]
}
