Formulas

field.value = entity["Density"] * entity["Volume"]

# 1. Bare expression (one-liner sugar)
entity["Volume"] * 1.5

# 2. Explicit assignment
field.value = entity["Volume"] * 1.5

# 3. Top-level return
return entity["Volume"] * 1.5

entity["Reactor Temp (°C)"]
entity["Lot Number"]
entity["Supplier"]["Country"]              # chain across single REFERENCE
[m["SKU"] for m in entity["Materials"]]    # iterate multi REFERENCE
seal.sum(entity["Items"], "Quantity")      # aggregate (one SQL query)

reading = entity.fields.get("Reading")
if reading is not None and reading.value > 100:
    field.warning = "Out of spec"

# WRONG — "Supplier" is single REFERENCE → KeyError: "Field '0' not found"
entity["Supplier"][0]["Country"]

# CORRECT
entity["Supplier"]["Country"]

# WRONG — "Decision" is single SELECT → returns the first character ("B" from "Blocked"), silently
field.value = entity["Decision"][0]

# CORRECT
field.value = entity["Decision"]

# CORRECT — "Materials" is multi REFERENCE, list shape
[m["SKU"] for m in entity["Materials"]]
entity["Materials"][0]["SKU"]

# WRONG — upstream "F-33 Centrifuge" is multi, target is single → run errors
ref = entity["F-35 - Drying"]
field.value = ref["F-33 Centrifuge"]

# FIX EITHER SIDE
# (a) make the target field allow multiple (matches the upstream model), or
# (b) collapse explicitly to a single value:
field.value = ref["F-33 Centrifuge"][0] if ref["F-33 Centrifuge"] else None

if not entity["Approved"]:
    skip()

if entity["Reading"] > 100:
    field.warning = "Out of spec"

# Sum amounts grouped by unit — returns {"g": 12.3, "kg": 0.5, "mL": 200.0}
totals = seal.sum(entity.referenced_by, "Amount",
                  group_by="Unit",
                  where={"template": "Line Item"})

# First finished lot among referenced lots
lots = seal.filter(entity["Lots"], where={"status": "FINISHED"})
field.value = lots[0]["Batch ID"] if lots else None

# Comma-separated names of active items
active = seal.filter(entity["Items"], where={"fields": {"Status": "Active"}})
field.value = ", ".join(item["Name"] for item in active)

# All finished backlink entities of a given template
results = seal.filter(
    entity.referenced_by,
    where={"template": "Experiment", "status": "FINISHED"},
)

# The single Lot Record reachable through this entity's backlinks
lot = seal.only(entity.referenced_by, where={"template": "Lot Record"})
field.value = lot["Batch ID"] if lot else None

# An author-typed multi-REFERENCE narrowed to one match — assert at most one
# active item is selected, raise loudly otherwise
active = seal.only(entity["Items"], where={"fields": {"Status": "Active"}})
field.value = active["Quantity"] if active else 0

where = {
    "template": "Lot Record",        # name (resolved) or UUID
    "type":     "Sample",
    "kind":     "instance",           # lowercase — matches entity.kind
    "status":   "FINISHED",           # uppercase — matches entity.status
    "archived": False,
    "fields": {                      # mirrors entity.fields[...]
        "Status": "Active",
        "Region": "EU",
    },
}

# On an Equipment template — adds up hours across every Experiment that
# references this equipment, filtered to finished runs only. One SQL
# aggregate, regardless of count.
field.value = seal.sum(
    entity.referenced_by,
    "Hours Logged",
    where={"template": "Experiment", "status": "FINISHED"},
)

# On a child template's "Donor" REFERENCE field. Reads the parent (via
# entity.created_from) and forwards its Donor. Runs on entity creation and
# whenever the user clicks Recompute on the formula.
entity.created_from["Donor"]

# On a child's "Materials" multi-REFERENCE field
entity.created_from["Materials"]

field.value = entity["Created"] + timedelta(days=7)
field.value = (datetime.now() - entity["Started"]).days
field.value = datetime(2026, 1, 1)

for sib in entity.siblings:
    print(sib.title)

entity.siblings.by_id("...")    # SiblingEntitySummary | None
entity.siblings.ids             # list[str]
entity.siblings.titles          # list[str | None]
len(entity.siblings)            # 0 when not in a creation field

# Title formula — assign to the `title` global
title = f"{entity['Compound']} — Batch {entity['Batch Number']}"

# Status tag formula — string for text-only, or (text, intent) tuple
if entity["Approved"]:
    status_tag = ("Approved", "success")
else:
    status_tag = ("Pending", "primary")

# Bare expression — compiles to `title = ...`
f"{entity['Compound']} — Batch {entity['Batch Number']}"

# Explicit return
return f"{entity['Compound']} — Batch {entity['Batch Number']}"

print(f"computed {entity['Input']} → {entity['Input'] * 10}")
field.value = entity["Input"] * 10

if entity["Volume"] is None or entity["Density"] is None:
    skip()
field.value = entity["Volume"] * entity["Density"]

field.value = entity["Reading"]
if field.value is not None and not (10 <= field.value <= 90):
    field.warning = f"{field.value} outside spec range 10–90"

field.value = seal.sum(entity["Line Items"], "Quantity")

if entity.last_published_at is None:
    skip()
field.value = (datetime.now() - entity["Published Date"]).days

# Copy the reviewer of the parent batch onto this sub-batch
parent = entity.created_from
field.value = parent["Reviewer"] if parent else None

# field.value on "Total quantity (mL)" — the canonical intermediate
field.value = sum(item["Volume mL"] for item in entity["Items"] or [])

# field.value on "Total quantity display" — reads the intermediate, formats it
total = entity["Total quantity (mL)"] or 0
field.value = f"{total/1000:.2f} L" if total >= 1000 else f"{total:.0f} mL"

# Seeded by Migrate — your math.js body, preserved verbatim
field.value = legacy_formula('@"Volume" * 2')

# Equivalent native per-field formula — rewrite when you're ready
field.value = entity["Volume"] * 2