tokens

const (
	CodeTextHex     = "#E6E6F0" // the primary text tier, restated so the ramp reads whole
	CodeKeywordHex  = "#C9BDE5" // indigo
	CodeStringHex   = "#ADE0BE" // leaf
	CodeNumberHex   = "#E8CFA4" // sand
	CodeCommentHex  = "#838A9E" // slate — the one receding slot
	CodeFunctionHex = "#A8D6EA" // sky
	CodeTypeHex     = "#E8B4CE" // orchid
)

const (
	// GlyphProseBullet is the mark on an unordered list item. It is the middle
	// dot rather than U+2022 because the middle dot is already measured and
	// already shipping in this tree, and because 5.13 asks structure to be the
	// quietest thing on the row: the INDENT is what says "list", the mark only
	// says "item".
	GlyphProseBullet = "·"
	// GlyphProseQuote is the gutter bar down the left of a blockquote —
	// structure without boxes (5.21), one column wide.
	//
	// IT IS THE HAIRLINE AND NO LONGER THE BOX RULE. It was `│` — the same byte
	// the spawn tree's trunk ([GlyphTreeVert]) and every vertical rule in the
	// product are drawn from — and a blockquote sat at the left margin of the
	// chat feed while the margin column's own divider ran down the right of the
	// very same rows, so on a screen with no other vertical rules two `│`
	// columns meaning unrelated things read as one broken frame. The fence
	// beside it already owned the right mark for "this block is set apart", so
	// the quote takes [GlyphCodeGutter]'s byte instead: an eighth of a cell,
	// which is a margin and cannot be mistaken for a frame.
	GlyphProseQuote = "▏"
	// GlyphCodeGutter is the hairline down the left of a fenced code block. It
	// is one eighth of a cell of ink: enough to bound the block on the side the
	// eye returns to, and far too little to read as a border. There is no line
	// number beside it — a number column is a second thing to read in a region
	// the reader opened in order to read something else.
	GlyphCodeGutter = "▏"
)

const (
	// CountCellWidth fits "999", "1.5K", "25K", "1.2M" — the ladder never
	// produces more than four cells.
	CountCellWidth = 4
	// DurationCellWidth fits "4.5s", "45s", "3m12s", "59m59s", "2h14m",
	// "99d23h".
	DurationCellWidth = 6
	// ElapsedCellWidth fits "45s", "5m", "1h02", "99d23" — the aging form,
	// which drops the trailing unit so the granularity switch never jitters.
	ElapsedCellWidth = 5
	// PercentCellWidth fits "5.1%" and "100%".
	PercentCellWidth = 4
	// ContextCellWidth fits "5.1%/1M" and "100%/128K".
	ContextCellWidth = 9
	// MoneyCellWidth fits "$999.99" and "$1.2K".
	MoneyCellWidth = 7
)

const (
	// State vocabulary. Shape encodes state CATEGORY and may change at a true
	// state transition; shape never animates on a long-lived row (8.1.6).
	GlyphQueued  = "○"
	GlyphWorking = "◐"
	GlyphSettled = "✓"
	GlyphFailed  = "✕"
	// GlyphStopped is work A PERSON ENDED, and it is deliberately neither
	// [GlyphSettled] nor [GlyphFailed]: a tick is a finding that the work came
	// off and a cross is a finding that it did not, and nobody found anything
	// about work somebody stopped. The filled square is the mark every device a
	// person owns stops with, it is one cell under both shipping rulers, and it
	// is the shape the nerd-font tier has an exact icon for (nf-fa-stop).
	GlyphStopped = "■"
	// GlyphPaused is 5.17's replacement for the banned ⏸: a paused row is
	// "=" (or a dim GlyphQueued, at the renderer's choice).
	GlyphPaused = "="

	// Attention and blocking.
	GlyphNeedsHuman = "?" // always amber (5.16)
	GlyphWaitsOn    = "⚑" // waiting on a sibling (waits-on edge)
	// GlyphWithdrawn is a question that STOPPED BEING A QUESTION — its subject
	// went away, the plan changed, or another answer made it moot, so the asker
	// took it back (docs/design/questions/DESIGN.md's WITHDRAWN, WITH A REASON).
	//
	// It is deliberately none of the three marks it sits nearest. A tick says
	// somebody decided; a cross says the answer was no; a filled square says a
	// person ended it. Nobody decided anything here and nobody ended anything —
	// the decision simply stopped needing to be made — and the circled slash is
	// the one shape in the geometric register that says "this does not apply"
	// without claiming an outcome.
	GlyphWithdrawn = "⊘"
	// GlyphAssumed is the ladder's SECOND rung drawn: the asker has taken
	// something for granted, said so, and gone on — and everything on the card
	// stands until somebody strikes it (docs/design/questions/DESIGN.md names
	// this mark for the assumption kind).
	//
	// IT IS NOT [GlyphNeedsHuman], and that is the whole reason the slot exists.
	// `?` means "waiting on a person" and is the one mark on this surface that
	// is always amber; an assumptions card is waiting on nobody — it is going
	// ahead, and the offer to strike a line is a courtesy rather than a gate.
	// Drawing it with the attention mark told a person to answer something that
	// was not asking them anything, which is the fastest way to make the amber
	// mark stop meaning what it says.
	//
	// It is also not [GlyphEstimate]. A tilde is bound to a NUMBER — 10.2.8's
	// "estimated number" — and this stands alone at the head of a card; the two
	// are near neighbours in shape and say different things, which is exactly
	// the distinction the one-glyph-one-meaning gate exists to keep.
	GlyphAssumed = "≈"

	// Disclosure and navigation.
	GlyphCollapsed = "▸"
	GlyphExpanded  = "▾"
	GlyphScopeUp   = "‹" // scope header / go up

	// GlyphPointer is THE PERSON'S POINTER ON A QUESTION: the answer `enter`
	// takes. It is the fold mark's own small triangle, and deliberately so —
	// both say "this row, and your key goes into it" — but it is a SLOT of its
	// own because a question's pointer is amber and moves under a hand, where a
	// fold mark is a dim fact about a section; one slot for both was the
	// question's page drawing `▸` for "folded" beside `▸` for "you are here"
	// (docs/design/questions/DESIGN.md, 2026-09-11).
	GlyphPointer = "▸"
	// GlyphRecommended is THE ASKER'S PICK: the answer the thing asking would
	// take, drawn at the right edge of that answer's row with the word
	// `recommended` beside it. It is amber, like the other two marks of a
	// question, and it is a filled shape where the pointer is a triangle so the
	// two can stand on one row and never be read as each other.
	GlyphRecommended = "◆"

	// The one frame (internal/tui3/frame.go): a rounded, dim edge around the
	// one object on the surface that is waiting for a person (a question), and
	// around the few sheets raised over the page on purpose. Box drawing is
	// already the right character for a grid, so these are geometry: the tier
	// never touches them, and a terminal refused box drawing gets the frame's
	// own ASCII run (two plain rules, no sides), which the frame draws itself.
	GlyphFrameTopLeft     = "╭"
	GlyphFrameTopRight    = "╮"
	GlyphFrameBottomLeft  = "╰"
	GlyphFrameBottomRight = "╯"
	GlyphFrameEdge        = "─"
	GlyphFrameSide        = "│"
	// The two junctions are where a frame's rule meets the seam between two
	// panes laid side by side (internal/tui3/panes.go): the rule above the panes
	// drops into the seam and the rule below closes it. They are the same
	// geometry as the rest of the frame, so they are drawn at the same floor.
	GlyphFrameTeeDown = "┬"
	GlyphFrameTeeUp   = "┴"

	// GlyphTarget is WHERE THE NEXT THING GOES, and it is the one mark in this
	// vocabulary about a destination rather than about a state. Home's rule wears
	// it in front of the folder and the model the next conversation will open on
	// (internal/tui3's homedraft.go), and the whole of its meaning is the
	// difference between "where I am" and "where this is going" — which is why it
	// is neither [GlyphScopeUp], a header pointing back up a tree, nor
	// [GlyphPromptSteer], a composer's own prompt.
	//
	// IT IS GEOMETRY ON PURPOSE. An arrow is already the right character for a
	// grid, exactly as the tree corners and the rails are, and a Font Awesome
	// arrow in its place would buy nothing and spend a private-use codepoint.
	GlyphTarget    = "→" // where the next thing goes
	GlyphTruncated = "⋯" // clickable overflow; [GlyphEllipsis] marks static overflow

	// GlyphEllipsis is §16's ONE ELLIPSIS GRAMMAR as a slot: the mark text
	// leaves behind when it was too long for its column. It is deliberately NOT
	// [GlyphTruncated] — an ellipsis says "the rest is off the edge", a ⋯ says
	// "there is more, click for it", and a cut ([GlyphCut]) says "this stopped
	// and should not have". Three marks, three sentences.
	//
	// It was the most-drawn mark in the product with no name here: prose,
	// placeline, modelui, palette, footer and composer each spelled the
	// byte themselves, and three of them wrote a comment explaining which of
	// the other two marks they did NOT mean. The slot ends the explaining.
	//
	// U+2026 is Ambiguous width and one cell under both shipping rulers. It has
	// no nerd-font twin on purpose: the tier's ellipsis icon is already spent on
	// [GlyphTruncated], and this mark lands inside sentences a user wrote, where
	// a rewrite would be an edit rather than a repertoire swap (12.7 D.2).
	GlyphEllipsis = "…"

	// GlyphCut is the truncation law's visible mark (12.5.2): a turn ended by
	// anything other than its own completion renders VISIBLY CUT. The severed
	// double-dash rule is deliberately NOT [GlyphTruncated] — an ellipsis says
	// "there is more, ask for it", and a cut says "this stopped and should not
	// have". Conflating the two is exactly the lie of omission 12.5 found.
	// Colour comes from [CutToken]; U+254C is Neutral width, one cell under
	// every ruler including a CJK locale.
	GlyphCut = "╌"

	// Composers. The two prompts differ so the affordance never lies about
	// which surface the draft will land in (5.15).
	GlyphPromptChat  = "›"
	GlyphPromptSteer = "↦"
	// GlyphReplyIn is AN ANSWER DRAWN UNDER THE THING IT ANSWERS: the reply to a
	// question a person put back to the asker, the response landing on the row
	// that asked for it (docs/design/questions/DESIGN.md's room form). It is a
	// prompt mark in the same family as the two above — punctuation saying whose
	// turn a line is — which is why it is geometry and neither tier swaps it.
	//
	// It is deliberately NOT [GlyphPromptChat]: `›` is the person typing and this
	// is what came back, and a page that drew both with one mark would make an
	// exchange unreadable at exactly the moment it matters. U+21B3 is
	// East_Asian_Width=Neutral and one cell under both shipping rulers.
	GlyphReplyIn = "↳"
	// GlyphDraftUnsent is a message a person typed and then CLEARED the whole
	// box into — the mark the /drafts page draws in front of each line that
	// is still waiting to come back (internal/tui3's draftpage.go).
	//
	// IT IS PENCIL-SHAPED LIKE [GlyphWrite] AND NOT THE SAME PENCIL. ✎ is the
	// step gutter's "a call wrote something down"; ✐ (U+2710 LOWER RIGHT PENCIL)
	// is a thing the hand still holds. It is also deliberately NOT the steer
	// prompt's mapped-into arrow one slot up: a draft has gone nowhere yet, it
	// sits on the wrong side of the line that one draws.
	GlyphDraftUnsent = "✐"

	// The execution voices (5.5). A work record is four speakers and no
	// labels: the model thinking, the tools it reached for, the reader
	// steering, and what came back. The reader's voice is [GlyphPromptChat]
	// — the same mark they typed at — and what came back wears the quote
	// gutter, so the slots this adds are the three the vocabulary was short:
	// the model's own thought and the two tool kinds that are not a shell.
	//
	// All three measure one cell under both shipping rulers and all three are
	// East_Asian_Width=Neutral, so they are the rare glyphs that do not even
	// cost a reserved column under a CJK locale.
	GlyphThought = "✳" // the model's own words between calls
	GlyphShell   = "$" // a shell call — the prompt a person types at
	GlyphSearch  = "⌕" // a call that went out to the world
	GlyphFilter  = "⌕" // narrowing what is already on the page
	GlyphWrite   = "✎" // a call that wrote something down

	// The action families (internal/tui3's step gutter). One still, monochrome
	// mark per FAMILY of work — searching, editing, running a command — keyed
	// off the closed vocabulary the engine carries in session.ActionCategory.
	//
	// THEY ARE SLOTS HERE AND NOT CHARACTERS THERE. The surface used to hold
	// its own three-tier table, with the private-use codepoints spelled inline
	// beside the plain marks, so ten icons and ten plain glyphs lived outside
	// the width gate, outside the ban list and outside the one-meaning law —
	// which is how ▤, ◎ and ◷ came to be drawn product-wide without ever having
	// been measured. Four of the families reuse a slot this table already owns
	// (search, write, shell, and the diff-add byte for a thing that was not
	// there); the rest are named here, and the surface keeps only the map from
	// a family to a slot.
	GlyphActionRead        = "▤" // a box with lines in it — a page of text, opened
	GlyphActionCreate      = "+" // something that was not there is
	GlyphActionTest        = "◎" // a target being aimed at — NEVER a checkmark
	GlyphActionBrowse      = "↗" // out of here and onto a page somewhere else
	GlyphActionTransfer    = "⇄" // bytes going the other way as well
	GlyphActionCommunicate = "»" // the guillemet: something being SAID, to a person
	GlyphActionCoordinate  = "⇉" // work handed out, or this mind copied to run beside itself
	GlyphActionPlan        = "≡" // three level lines, an outline
	GlyphActionWait        = "◷" // a quarter of a clock face, still
	GlyphActionWork        = "▪" // a small square: "a step", which is all it knows

	// Meta.
	GlyphBoosted   = "⇡" // transient escalation of the work-role binding (8.2.16)
	GlyphSeparator = "·" // telemetry separator
	GlyphMissing   = "—" // missing data — never an estimate (10.2.8)
	GlyphEstimate  = "~" // estimated number (10.2.8)

	// Structure (5.21). The accent rail groups a card's lines in its identity
	// hue; the drag handle marks a reorderable pending row (5.22).
	GlyphAccentRail = "▎"
	GlyphDragHandle = "⋮"

	// GlyphHugEdge is the composer hug's left edge: the one cell at column 0 of
	// the row you type into, carrying the composer's state colour.
	//
	// It is U+258D LEFT THREE EIGHTHS BLOCK and NOT [GlyphAccentRail], and the
	// distinction is the vocabulary's whole point rather than a shade of taste.
	// §4 spends `▎` on one meaning product-wide — "a finished answer" — and says
	// nothing else may wear it. The hug's edge means something else entirely:
	// "this is the live surface, and here is what it is doing right now". Two
	// meanings may not share a mark, so the hug takes the next rung of the same
	// eighth-block ladder the code gutter (`▏`) and the accent rail already
	// stand on: same family, so the three read as one system, different width,
	// so they are told apart at a glance and by the table.
	GlyphHugEdge = "▍"

	// GlyphChipCapLeft and GlyphChipCapRight are the two cells that soften a
	// filled chip's ends: U+2590 RIGHT HALF BLOCK opens it and U+258C LEFT HALF
	// BLOCK closes it, each painted with the CHIP's ground as its FOREGROUND
	// over the surface's own ground. Half a cell of chip and half a cell of
	// floor, which is as close to a rounded corner as a terminal gets.
	//
	// They are geometry rather than iconography — the shapes ARE the meaning,
	// there is nothing for a patched font to improve, and both measure one cell
	// under both shipping rulers like every other eighth/half block already in
	// this table. They are named here rather than spelled inline for §16's flat
	// reason: a mark drawn from a literal escapes the width gate, and the day a
	// second surface wants a filled chip it must get the same two cells.
	GlyphChipCapLeft  = "▐"
	GlyphChipCapRight = "▌"

	// Step dots: plan progress as one dot per step (5.21). Display only on
	// narrow rails — too small to hit honestly (5.22).
	GlyphStepDone    = "●"
	GlyphStepRunning = "◐"
	GlyphStepPending = "○"
	GlyphStepBlocked = "⚑"

	// Run progress cells summarize task state across a whole run.
	GlyphDoneCell    = "●"
	GlyphRunningCell = "◐"
	GlyphEmptyCell   = "○"
	GlyphFailedCell  = "✘"

	// Queue pills: one glyph per queued item, capped (10.3.13).
	GlyphQueuePill = "▶"

	// Diff micro-stats on settle rows (5.21), green and coral, tabular. The
	// minus is U+2212, which is one cell in every width mode and lines up with
	// the plus; ASCII '-' does not.
	GlyphDiffAdd = "+"
	GlyphDiffDel = "−"

	// The compact inline spawn tree written into the committed transcript at
	// birth and settle (10.3.11).
	GlyphTreeBranch = "├"
	GlyphTreeLast   = "└"
	GlyphTreeVert   = "│"
	GlyphTreeDash   = "─"

	// The place line (5.19): where work lands on disk. These three were drawn
	// in 5.19's own example before they had names here, and they are plain-tier
	// glyphs in their own right — the glyph TIER (12.7) upgrades them, it did
	// not invent them.
	//
	// GlyphHome is U+2302 HOUSE, Neutral width and universally covered, which
	// is why 5.19 reached for it. GlyphFolder is the ASCII slash, because a
	// slash already means "directory" in every shell anyone has ever used and
	// no font can fail to draw it. GlyphGitBranch is U+22D4 PITCHFORK, Neutral
	// and one cell; where a font cannot draw it the documented substitute is
	// ":" — the "git:main" convention — which is ASCII and the same width.
	GlyphHome      = "⌂"
	GlyphFolder    = "/"
	GlyphGitBranch = "⋔"

	// The status line (5.17's "K3 ▄ $8.65"). The model mark is U+25C7 WHITE
	// DIAMOND, one cell under both rulers and Ambiguous exactly as the gauge
	// beside it already is. The spend mark is the dollar the money cell was
	// already carrying, named so the tier can swap it as a slot rather than as
	// a substring.
	//
	// The `$` is spelled twice on purpose and it is the one collision in the
	// vocabulary worth stating out loud: [GlyphShell] is the same byte saying a
	// different thing (a shell call, 5.5). They are told apart by what follows —
	// the spend mark is bound to a number and the shell mark is followed by a
	// space — never by shape, and the nerd-font tier separates them outright
	// (nf-fa-dollar against nf-fa-terminal). glyphvocab_test.go carries the pair
	// in its named-exceptions table so a THIRD `$` slot has to be argued for.
	GlyphModel = "◇"
	GlyphSpend = "$"

	// The file kinds. A chip says WHAT KIND OF THING is on the end of a path
	// before it says the path, and so does the gutter beside a call that made
	// one or opened one; the four kinds a person can hand this program are the
	// four here.
	//
	// GlyphFileDocument is [GlyphActionRead]'s byte on purpose — a page of text
	// is a page of text whether a call opened it or a person dragged it in, and
	// the tier draws the SAME icon for both rather than inventing a distinction
	// the floor does not draw. It is the one collision in this block, and it is
	// carried in glyphvocab_test.go's named-exceptions table.
	//
	// GlyphFileVideo is U+25B7 WHITE RIGHT-POINTING TRIANGLE and NOT the filled
	// U+25B6 a chip used to draw: the filled triangle is [GlyphQueuePill]'s, one
	// plain byte may upgrade exactly one way, and an outline triangle is the
	// right weight beside three outlined file icons anyway.
	//
	// GlyphFileImage is U+233E APL FUNCTIONAL SYMBOL CIRCLE JOT and
	// GlyphFileAudio is U+266A EIGHTH NOTE, both one cell under both rulers.
	GlyphFileDocument = "▤"
	GlyphFileImage    = "⌾"
	GlyphFileAudio    = "♪"
	GlyphFileVideo    = "▷"
)

const (
	MotionIntervalMin = 100 * time.Millisecond
	MotionIntervalMax = 150 * time.Millisecond
)

const (
	MotionPeriodMin = 800 * time.Millisecond
	MotionPeriodMax = 2 * time.Second
)

const (
	PulseSteps  = 12
	PulsePeriod = PulseSteps * MotionInterval
)

const (
	// DimTowardGround is how far a token's dimmed variant travels toward the
	// ground. 0.45 is the point where the whole pane visibly recedes while
	// every body-class token still clears 3.0 contrast (contrast_test.go).
	DimTowardGround = 0.45

	// BandIdentityTint is how much identity hue the selection band takes when
	// the user is inside that task's scope (5.16: "the selection band tint
	// inside that task's scope"). 0.08 is the largest tint at which the chrome
	// tier still clears 3.0 on the tinted band — the tint is meant to be
	// answered peripherally, never noticed.
	BandIdentityTint = 0.08

	// SheetTowardBand is how far the floating dialog's own ground travels from
	// the [Ground] toward the [Band] — the one derivation that makes the
	// elevation ladder ground → sheet → band monotone by construction rather
	// than by three hand-picked literals.
	//
	// 0.45 is chosen by the two ends it has to satisfy at once, and both are
	// tight: below about 0.35 the sheet resolves to the SAME xterm-256
	// greyscale entry as the ground (the cube is coarse in this corner — see
	// [Sheet]) and the elevation disappears on the majority profile; above 0.5
	// the band it carries stops reading as raised against it. At 0.45 the sheet
	// is 1.09 over the ground and the band is 1.14 over the sheet, and the
	// three rungs land on three different 256 entries in the right order.
	SheetTowardBand = 0.45

	// HugBarTowardBand and HugInputTowardBand are the composer hug's two
	// grounds, on the same ground→band axis the [Sheet] is derived along and
	// deliberately BELOW it.
	//
	// The hug is the two permanent rows at the bottom of a room — the input row
	// and the bar row under it — and it is not a dialog. A dialog is a thing
	// that arrived and will leave, so it may announce itself; the hug has been
	// there since the window opened and will be there when it closes, and a
	// permanent plane painted at the dialog's rung reads as a slab welded across
	// the bottom of the screen. Two rungs under the sheet is what "the floor
	// changes here" looks like when the change is allowed to be quiet.
	//
	// WHY TWO AND WHY THESE TWO. The input row sits one shade LIGHTER than the
	// bar row, which is the whole depth cue: the row you type into is nearer,
	// the row that names where you are is further back, and neither needs a
	// hairline to say so (16's SURFACE SEAMS ARE GROUNDS, and its ban on a third
	// ruled line). The numbers are bounded on three sides at once — the pair has
	// to stay under the sheet (0.45), has to clear [HugSeparationMin] from each
	// other, and has to survive the xterm greyscale ramp, which holds exactly one
	// step between the ground's entry (233) and the band's (235). 0.10 resolves
	// to 233 and 0.40 to 234, so the two-tone is real at 256 colours as well as
	// at truecolor; a bar rung above ~0.12 collapses onto the input rung's entry
	// and the depth disappears on the majority profile.
	HugBarTowardBand   = 0.10
	HugInputTowardBand = 0.40

	// CardWorkingTowardBand and CardDeliveredTowardBand are the two card
	// grounds, on the same ground→band axis every other rung is derived along.
	//
	// §4 gives the delivery card "a distinct ground + `▎` accent left edge" and
	// says nothing else may wear that treatment. These are the planes the two
	// card states stand on; without them the card would be carried by its edge
	// alone.
	//
	// WHY TWO. A task in the conversation has two states a reader must tell
	// apart at a glance — the one just made, and the one that came back — and
	// §16 says the way to separate them is a ground shift rather than a rule.
	// So the commitment card gets its own quieter rung and the delivery card
	// gets the louder one, and the STEP between them is what says "this
	// finished". The treatment stays unique because only the delivery wears the
	// edge as well: at NoColor, where neither ground is drawn at all, the `▎` is
	// still the only thing on screen that says "a finished answer".
	//
	// The numbers are bounded on three sides, exactly as the hug's are. The
	// delivered rung stays UNDER [BandSeparationMin] (1.1424 against a 1.15
	// floor), because a card raised as far as a selection is the slab §16
	// refuses and there would be nowhere left for a band drawn on top of it. The
	// pair clears [SheetSeparationMin] from each other (1.0914), so the step is
	// a step and not a rounding. And the two land on different xterm greyscale
	// entries, which is the tight one: the ramp holds a single step between the
	// ground's entry (233) and the band's (235), so a working rung authored much
	// higher collapses onto the delivered rung's entry and the difference exists
	// only on the profile nobody screenshots.
	CardWorkingTowardBand   = 0.25
	CardDeliveredTowardBand = 0.65
)

const (
	BandSeparationMin = 1.15
	BandSeparationMax = 1.70
)

const CaretMotion = "caret"

const HugSeparationMin = 1.05

const IdentityCount = 8

const MotionInterval = 120 * time.Millisecond

const NFFailedCell = "nf-fa-times_circle_o"

const PulseEase = 0.6

const SheetSeparationMin = 1.08

const SpinnerPeriod = time.Duration(len(SpinnerFrames)) * MotionInterval