---
title: "07. Information flow"
url: https://una-lang.org/en/docs/spec/07-information-flow/
release: v0.4.0
source: https://github.com/una-lang/una/blob/v0.4.0/docs/spec/07-information-flow.md
---

# 07. Information flow

Status: Normative, v0.1.

## 1. Guarantee and scope

Una enforces **termination-insensitive noninterference up to declassification** (theorem T6, `spec/10 §6`): for any observer at label `l`, two runs whose inputs differ only in values labeled above `l` produce the same values and effects observable at `l`, unless a declassification policy released information to `l`.

Observable channels in the model: return values, failure variants and payloads, capability operation arguments, the occurrence of effects.

Outside the model in v0.1, and reported as such in the build report (`spec/13 §6`, `out_of_model`): timing, termination and divergence, resource consumption and allocation, stack exhaustion, external systems beyond declared signatures, races between the check and the use of a file path, hard links, order of effects across concurrent tasks, the time of a host stop, interference of the host's load with the timing of an expression, uncatchable termination, waits at limits and at `start`, and which branch of `first of` wins, beyond its label (`spec/14 §3` and ADR 0048 for hard links; v0.2, ADR 0065 and `spec/19 §3` for the order of effects, which includes how far a canceled task got; edition 0.4 preview, ADR 0116 rule 21 and `spec/26 §6` for the time of a host stop, the interference of the host's load and uncatchable termination, and ADR 0117 rule 13 and `spec/27 §6`, `§7` and `§9` for the waits at `start` and at the limits of grants, and the winner of `first of`). T6 holds for the result of a `together` block and for each task's own events. A run-time abort is termination: running out of depth or memory (U6003), in v0.2 a header value with a control character (U6004), and host text that is not valid UTF-8 (U6005, S-16, ADR 0086).

## 2. Labels

A label is a pair `(level, categories)`.

- Levels, in order: `public` ⊏ `internal` ⊏ `confidential` ⊏ `secret` ⊏ `restricted`.
- Categories are declared per package in `una.toml` under `[labels] categories`. An undeclared category is U4007.
- Order: `(l1, C1) ⊑ (l2, C2)` iff `l1 ≤ l2` and `C1 ⊆ C2`. Join is componentwise (max level, union of categories).
- Bottom `⊥ = public` with no categories. Top `⊤ = restricted` with all declared categories.

Syntax: `secret[PII] Phone`, `confidential[Location, PII] Report`, `internal Hashed`. No prefix means `public`. (v0.3, ADR 0094.) The same label syntax follows `gives` after an operation in a header's `uses` (`spec/05 §3` rule 6): a principal on whose behalf the operation answers is a category.

## 3. Typing rules (informal; formal rules in `spec/10`)

1. **Explicit flows.** The label of an operation's result is the join of its operands' labels. Field access joins the record's label with the field's declared label. (v0.3, ADR 0094 rule 2.) The answer of a capability operation through a binding whose header gives it a label `l` (`spec/05 §3` rule 6) carries `l`, and so does the decision on whether it fails; the rule is stated in §7 rule 4, its last paragraph, where ADR 0094's amendment of this section lives.
2. **Program-counter label.** Branching (`if`, `when`, `if none`) on a value labeled `l` raises the pc to `pc ⊔ l` inside the branches. Values produced inside the branches are joined with the raised pc.

    ```una
    let flag = if r.age > 17 then 1 else 0    -- r.age : secret[PII] Int
    -- flag : secret[PII] Int
    ```

3. **Failures under pc.** `fail` and handling clauses that fail are allowed only when `pc = public` (U4002). Code that must branch on labeled data returns a labeled value instead of failing.
4. **Effects under pc.** A capability operation under pc requires `pc ⊔ label(args) ⊑ accepts` (U4003). A call to a function is allowed under pc only if `pc ⊑ bound(f)`, where `bound(f)` is the meet of the `accepts` labels of all effects `f` may perform, and `public` if `f` can fail (U4002). Pure, non-failing functions have `bound = ⊤`. A call of a function value labeled `l_f` is a call under `pc ⊔ l_f`, and its result is raised by `l_f` (T-App, `spec/10 §5`).
5. **Returns.** A function body's result label MUST be ⊑ the label of the declared return type (U4001).

## 4. Sinks

Every capability operation argument is a sink with the operation's `accepts` label (default `public`). Host capability sinks are fixed in `spec/14 §3` (for example, `Console.print` accepts `public`).

Text interpolation propagates labels: `"id {phone}"` has the label of `phone`. Printing it through `Console` is then U4003.

(S-45, #1552, ADR 0032 amendment of 2026-11-06.) A run's trace is a sink that accepts `public`, in every edition this compiler accepts: each item of an event is rendered at its label, an argument at its static label and an outcome at the label of the operation's decision, failure type and result (`spec/11 §5`), and whether an event occurs at all follows `spec/26 §6` rule 4. An example's trace is the exception: its data come from its source (ADR 0078).

`expect` lines in examples (tests, written `test` in edition `0.3`, `spec/08 §2`, ADR 0105) observe values for the test harness and are exempt from sink checks.

## 5. Declassification policies

Labels are lowered only through a `policy` declared in a trusted module.

```una
trusted module events.keys

import events.types (Phone)

pub policy attendee_key
  from secret[PII] Phone
  to internal Hashed
  via hmac_phone
  purpose "attendee lookup and audit correlation"
  owner privacy

hmac_phone(phone: secret[PII] Phone) -> internal Hashed
  uses @keys: Keys[hmac]
  fails KeyError
=
  @keys.hmac(key_name: "phone_pepper", data: phone)
    if error pass
```

1. A policy `p` defines a callable `p(v: From) -> To` whose `uses` and `fails` are those of its `via` function.
2. At a call `p(v)`: `v` flows into `From` by normal subtyping, and `pc ⊑ label(To)` (U4002).
3. The `via` function MUST be private to the trusted module (U4005): the policy is the only entry point. Inside `via` functions, information-flow checks are not performed; they are part of the TCB, with one exception in edition `0.4`, the concurrent label of their timing sites (rule 7). Only label premises are skipped: every refinement, precondition and postcondition obligation remains, including the obligation that the result of the `via` function satisfies the refinement of the `to` type (ADR 0038 D5). T-Declassify assumes that refinement only because it was proven there.
4. Types other than labels MUST match between the policy and its `via` function (U4005): the parameter type of the `via` function equals `from` except for labels, refinements included, and its result equals `to` except for labels, so a refined kind in one and not the other, or two different refined kinds, is U4005 at `via`. A `via` function MUST NOT have a `requires` clause (U4005 at the clause): a policy call checks its argument against `from` only, so the argument meets every assumption the `via` body makes about its parameter (ADR 0047).
5. Every policy call site appears in the build report's Information section with the policy name, purpose and owner.
6. (ADR 0090, S-18.) The failure of a policy call is labeled `pc ⊔ ℓ(To)`, where its release is visible: the `via` function decides it from the `from` value, unchecked (rule 3). `attempt p(v)` gives a `Result` with that label, and `if error pass` and `if error fail` are U4002 when it is above `public`. A policy whose `To` is `public` keeps a public failure. (ADR 0098.) A `via` function whose only failure points are `Keys.hmac` calls with a literal key name, at the top level of its body and handled by `if error pass` or `if error fail` without a payload, decides nothing from the `from` value: its policy's failure is labeled `pc` (`spec/10 §13.4`).
7. (v0.4, ADR 0098, amendment of 2026-11-06.) **The timing sites of a `via` function.** A deadline or race outcome may reach the result of a `via` function only if its concurrent label is `public`: the site's `τ_conc`, as each site's timing label defines it (`spec/26 §7` rule 5 item 5, `spec/27 §5` rule 8, §6 and §10), computed today by the preview's rule of `spec/27 §11` (its first paragraph), even at the sites whose timing label already takes the precise `τ_conc` of `spec/27 §11`; the precise rule (`conc(n) ⊔ ctx(e)`) is lower and is not used here until a card adopts it (#1087), and either is what the program's other work, running beside the site, can make of its timing. The residue label `L_res` is not part of it; a stricter definition that joins `L_res` is not part of this rule. Since no label is checked inside a `via` body (rule 3), every outcome of a timing site that the body reaches counts as reaching the result. So each `within` (`spec/27 §5`, `start ... within` included), `first of` (`spec/27 §6`), `for ever within` (`spec/26 §7`) and statement that an installation of `limiter` scopes over (`spec/27 §10`), in a `via` body or in code it reaches along the call graph of ADR 0116 P1, with the edge of each policy call to its `via` function, is U4001 at the site when its concurrent label is above `public`. The other items of the site's timing label are the `via`'s own data and stay unchecked. A `via` with a timing site is therefore accepted for a policy called where no part of a task construct can run beside it, as the conformance case `security/via_hmac_within`, except where a function value can come from outside the code it reaches, below, and refused where a part that reads data above `public` can run beside it. The concurrent label checked is the preview's `τ_conc` of `spec/27 §11` until the precise one lands. The code a `via` body reaches counts each lambda with the function or handler it is written in. A function value that a `via` body, or code it reaches, calls or applies (a function given to `map` by name, say) is one of the lambdas written in that code or one of the functions it names as values, which the reach follows from where they are written, unless a value can come from outside that code (#1710): a parameter of the `via` whose type can hold a function value, the answer of an operation it reaches that can hold one, a handler it reaches whose parameters can hold one or whose operations call a function value, since its parameters and state come from whoever installed it, or a function it reaches outside the findings (a standard module but the one named exactly `prelude`, so `prelude.map` and `std.collections` included, whose type parameters can hold one, or a dependency not checked with the package) whose parameters or result can hold one. Only then does the call graph's one node for all lambdas count: every lambda's code and every function named as a value count as reached, and their timing sites are checked against this rule wherever the policy is called (`security/via_result_handler_value`); otherwise they do not (`security/via_result_value_call`). This takes a second search of the graph only when such a source is reached, and one look at each node the first search reaches with a table of what each operation answers built once, O(V + O log O) for the O operations (`tests/via_reach_scaling.rs` of `una-check`). A site already refused with U4001 at its own span, as a `limiter` that can run beside other tasks always is by `spec/27 §10`, gets that one diagnostic. The check is one search of the call graph from every `via` function at once, O(V log F + E + A log A) for `A` applications of functions whose code is not known at the call, and O(log n) per site, with a scan of the diagnostics so far for each site it refuses. No released line has timing sites. (ADR 0116 amendment of 2026-11-09, accepted, C7, #898.) A reading of `Clock.now` that a `via` body reaches in the same way is U4001 at the reading when its timing label `L_clk` (`spec/14 §3`) is above `public`, all of it and not only its concurrent label, since that label is the timing of the policy's callers, not the `via`'s own data.

## 6. Trusted modules

A module is trusted only if its header says `trusted module` **and** it is listed in `una.toml` under `[trusted] modules` (U7005 if either is missing). Policies are allowed only in trusted modules (U4004). All other code in a trusted module is checked normally. Trusted modules and their line counts are listed in the TCB section of the build report.

(v0.3, ADR 0093 rule 8.) A boundary module (`spec/05 §4` rule 5) never releases: it is never trusted (U7002, `spec/13 §7`), and a call into a boundary from which a policy call is reachable is U3024 at the call, with the policy call as the related span. Reachability follows the call graph: the callee's body, the functions it calls, the handlers it installs or receives, and the function values and lambdas given to it. A function value given to the boundary whose code is not known at the call, from a parameter, a local, a computed value or a kind's field, either as an argument or captured by a lambda given to it, is U3024 at the call, with the value as the related span, unless no policy is declared in the package or the modules it imports: then nothing releases. A named function and a lambda are followed, together with the handlers that their `uses` resolve to where they are written, which they run on whoever calls them; a binding captured by a lambda written outside the call is not followed, so such a value counts as one whose code is not known. What the arguments of a handler's installation give it, the handler may run wherever it is installed: the named functions and lambdas among them are followed from the handler, and a function value whose code is not known at the installation counts as above for every call into a boundary that may run the handler. A handler installed outside the call and granted on to it by name (`spec/05 §4` rule 5) is followed from its installation: a release it reaches is U3024 at the installation, with the release and the call as related spans, and so is a function value whose code is not known that it may run, when a policy is declared.

## 7. Checking

These rules fix how the checker applies this chapter and `spec/10` (ADR 0031).

1. **Structural labels.** Every position of a type carries a label, and an unlabeled position is `public` (`spec/03 §5`, `spec/09 §2`). Type equality ignores labels. A type variable keeps the join of the labels of every type it is unified with, so an instantiation of a generic function or kind carries the labels of all its arguments.
2. **Flows.** A value flows into a declared type at a call argument, an operation argument (rule 4), a constructor field, an annotated `let`, a return path, the `from` type of a policy and a lambda's result. The flow holds when every position of the value's type is labeled below the declared label at that position: covariantly through `List` and the covariant parameters of kinds, since values are immutable, contravariantly through function parameters (S-Refine, S-Fun), and with equal labels at every position of an argument of an invariant parameter of a kind (ADR 0046). A type parameter of a record or sum kind is invariant when it occurs anywhere inside a function type in the types of the kind's fields and variant fields, as a parameter or a result, or under an invariant parameter of another kind; otherwise it is covariant, as the parameters of `Option` and `Result` are. Recursive and mutually recursive kinds take the least solution. A branch join and a list literal are flow sites too: each branch of `if`, `when`, `if none use` and `if error use`, and each element of a list literal, flows into the joined type. Otherwise it is U4001 at the value. The arguments of one call are compared after all of them are typed. A lambda's type records the labels its body assumed for its parameters, so a parameter whose type variable rises after the body was checked, like the accumulator of `fold` over labeled values started from a `public` value, fails the flow of the lambda into its parameter. A `Unit` position carries no information and never fails a flow. In a return position, `if`, `when` and `if none` whose condition, scrutinee or option is labeled above the result's top label are U4001 at that condition, once per construct. (v0.4, ADR 0073 J5 as amended on 2026-11-09, accepted on 2026-11-10.) In edition `0.4` and later, the arguments of a constructor of the prelude kind `Json` are the one exception among constructor fields: they do not flow into the fields' declared labels, and the result's top label carries every label they hold instead (`spec/23 §5` rule 2).
3. **Labels of values.** Literals are `public`. The result of an arithmetic, logical or comparison operator, an equality and an interpolation is labeled with the join of every label of its operands' types. The labels of a kind's type include the labels that its fields and variant fields declare, instantiated with its type arguments and through the kinds they contain, so `==` on a record with a `secret` field is `secret`, and so is an interpolation of it (v0.2, ADR 0068), which `Console` then rejects (U4003); the same deep label bounds sinks and labels the results of generic calls and prelude functions (rule 8). `.len`, `is` and `in` take the top label of their operand. That holds because a pattern's literal is a constant, and so is `public`: a text literal with interpolation in a pattern, an `is` of a `when` arm or of an expression, MUST be rejected with U4008, in every edition, since its text is computed from the values it interpolates (S-28, #801). A field access and a pattern binding take the field's declared type, instantiated, with its top label raised by the top label of the record or the scrutinee. The value of `if`, `when` and `if none use` is raised by the top label of the condition, scrutinee or option (T-If, T-Case). The result of a call of a function value is raised by the value's label.
4. **Operations.** An operation's arguments are sinks: `pc ⊔ ℓ⁺(arg) ⊑ accepts` for each argument (U4003), where `ℓ⁺` joins the labels at the covariant positions of the argument's type, the data the caller sends to the handler: the top label, list elements, the arguments of covariant kind parameters with the labels their kinds' fields declare, function results, and the parameters of function parameters; every label of an argument of an invariant kind parameter counts (ADR 0052). Each argument also flows (rule 2) into the operation's declared parameter type with every covariant position of that type taken as `⊤`, so the labels declared there do not bound the data the caller sends, which `accepts` bounds, since `accepts` would otherwise never exceed them (`Files.write` accepts `internal` content declared `Text`, `spec/14 §3`); contravariant positions, such as the parameters of a function type, and every position of an argument of an invariant kind parameter are compared as at any other call argument, since a handler body assumes them (U4001, ADR 0050). An inline lambda given as an operation argument is typed against the declared parameter type, as a lambda is against any expected type (`spec/03 §7`), so its result flows into the declared result type, labels included (U4001); a function value passed by name, or a lambda first bound with `let`, has its own type and is compared as this rule states (ADR 0081). Inside a handler operation body, every label of a parameter's type is raised by the operation's `accepts`. The result of an operation keeps its declared label, except `Keys.hmac` (ADR 0039): its `key_name` accepts `public`, its `data` accepts every label and is not a sink, and its result is labeled `internal ⊔ ℓ*(data)`; in a handler of `Keys`, `data` carries every label and the result may carry it (`spec/14 §3`). (v0.2.) Whether a host operation fails, and how, is labeled by the arguments that decide it, each capped at what the operation accepts, as the failure of a labeled prelude function is: every argument of `Http` (S-15, below); the path of `Files`, not the content; the key name of `Keys.hmac`, not the data. So `attempt` gives a `Result` with that label, `if error use` runs under it, and `if error pass` and `if error fail` are U4002 when it is above `public`. Since `Files.read` and `Keys.hmac` accept only `public` for the arguments that decide them, their failures stay `public`, unless the file-state label below raises those of `Files`. (S-15, ADR 0085.) Every argument of `Http` decides its failure, its body and the values of its headers included: the server receives them all and may decide the failure by them. So the failure of every request is `internal`, as its response is, since `Header` declares its value `internal`. (S-14, ADR 0085.) The file system outlives the call that writes it: where a `Files.write` lands decides which later `Files` operations fail, in the same run and in later runs of the package. So the failure of every `Files.read` and `Files.write` is also labeled by the package's **file-state label**. That label is the join, over every call of `Files.write` in the package, of three labels: its path's labels, the program counter at the call, and the highest program counter its code can be entered under. That last label is, for a function, the join of the program counters of its direct calls, each raised by its caller's own, over the call graph; for a function used as a value or a policy's `via` function, which may be called anywhere, the effect bound of rule 4, or `public` when it can fail; the effect floor for a handler operation; `internal` inside a lambda; and `public` in an example. It is capped at `internal`, which `Files.write` accepts at most for its path, so a higher path is U4003 and a higher program counter U4002 already. What a write writes is not part of it: it decides nothing that a later operation observes but resource consumption, which is outside the model (§1), and a later read returns it `internal` anyway. Writes by other programs or people are outside the model too (§1). (v0.3, ADR 0094 rule 2.) Through a binding whose header gives the operation a label `l` (`spec/05 §3` rule 6), the operation's answer carries `l` at every position of its result type, and the label of whether it fails, and of its payload, is joined with `l`: the decision on the outcome runs under `pc ⊔ l`, and a failure passed on, by `if error pass`, by a `fail` under the decision or as the function's own failure, is U4002 where it is observed below `l`, as any failure under a raised program counter is (S-18, ADR 0090).
   - **Effect floor** (ADR 0038 D4). A handler operation body is checked for the worst caller T-Op allows, whose program counter and arguments reach the operation's `accepts` label `l_o`. Every capability operation performed in the body satisfies `l_o ⊔ pc ⊔ ℓ(args) ⊑ accepts` of that operation (U4003), and every call in the body satisfies `l_o ⊔ pc ⊑ bound_eff(f)` (U4002), where `bound_eff(f)` is the meet of the `accepts` labels of the effects `f` may perform, `⊤` if it performs none.
   - **Failures and results** follow ordinary data flow: the body starts at `pc = ⊥` for failure checks, so a callee that can fail is checked against its full `bound(f)` at the body's own program counter, and the result flows into the operation's declared return type (U4001). The caller receives both at its own program counter, so they reveal nothing beyond the data that flows into them.
5. **Policies.** A policy in a module whose header does not say `trusted` is U4004 at its name; a header that says `trusted` without the listing in `una.toml` is U7005 only. The `via` function is a private function of the policy's module whose one parameter has the type of `from` and whose result has the type of `to`, except for labels and with the same refinements (U4005 at `via`), and which has no `requires` clause (U4005 at the clause, ADR 0047); any use of a `via` function other than through its policy is U4005. Inside `via` functions no label is checked (§5 rule 3, `spec/10 §9` rule 3).
6. **Exemptions.** `expect` lines of examples (§4), the bodies of `via` functions and clauses (`requires`, `ensures`, `where`, in the refinement language, whose labels the verifier erases) are not checked for labels. `do` lines are checked at `pc = ⊥`.
7. **Categories.** A category in a type's label or an `accepts` clause that `[labels] categories` does not declare is U4007 at the category; a single file declares no category.
8. **Generics** (ADR 0038 D3).
   - **Type arguments carry their labels.** Instantiating `T` with `secret[PII] Phone` binds the whole labeled type, and unification never drops a label.
   - **Symbolic labels.** In the body of a generic function, a value of a type parameter `T` has the symbolic label `ℓ_T`. A result derived from it, by a comparison, an equality, a field, arithmetic, an interpolation or a collection operation of `spec/14 §1`, carries `ℓ_T` joined with the labels of its other operands, by rule 3. A symbolic label is below a declared label only if the declared label is `⊤` or contains the same symbolic label, so a value labeled `ℓ_T` flows into a non-generic parameter, a field, an annotated `let` or a sink only where such a value is allowed whatever `T` is (U4001, U4003). The declared result type of a generic function is the exception: its value MAY carry the symbolic labels of the function's type parameters, and at each call they are replaced by the join of every label of the type that instantiates the parameter (`spec/10 §5`, generic instantiation).
   - **`ℓ_T` only in place** (#440). A plain `ℓ_T` labels only a position of type `T`, where it stands for the labels the value of `T` was passed with; at every other position a symbolic label of `T` is `ℓ*_T`. Substitution reads `ℓ_T` at a position of type `T` as the type argument's own labels, so an `ℓ_T` joined there from elsewhere, such as a condition labeled `ℓ_T`, would be dropped. The checker keeps this by construction, and the Core IR it exports keeps it too (`spec/13 §8`).
   - (v0.2, ADR 0066.) A comparison or `to_int()` on a constrained type parameter is labeled by the same rule, and `sort` labels every position with the join of all its elements and of the list (`spec/20 §4`).
   - (v0.2, ADR 0067.) **Result summaries.** In edition `0.2`, the call of a generic function declared outside the prelude raises only the positions of its result that can carry each symbolic label:
     - **Two symbolic labels.** In edition `0.2`, and in edition `0.1` since #354, the body tells `ℓ_T`, the label of a value of `T` as it was passed in, from `ℓ*_T`, every label of `T`'s type argument. A comparison, an equality, a field or another operator over `T` values, a condition on them, and every label that a deep join collects give `ℓ*_T` (rule 3); a value of `T` itself carries `ℓ_T`, and `ℓ_T ⊑ ℓ*_T`. For a parameter constrained by `Ord` or `Integer`, whose type arguments are scalars, the two are the same, and the value carries `ℓ*_T`.
     - The **positions** of a declared result type are its top, a list's element, each type argument of `Option`, `Result` or a kind, and the result of a function type, recursively. At a position that is a type parameter `T`, `ℓ_T` is the type argument's own labels, which substitution puts there, so the summary leaves it out; `ℓ*_T` there, as when a comparison of `T` values chooses which `T` value is returned, is in the summary.
     - **Decisions given to functions.** A function value called with an argument that carries `ℓ*_T` cannot be checked against it, since its parameter type says `ℓ_T`: the decision raises the call's result and its program counter instead, as the label of the value does (`spec/10 §5`, T-App). When the function is a parameter that an `of` clause names, its effects are its callers': each caller runs its argument under `ℓ*(σ(T))` for the decisions that reach the parameter's calls, as `first_where` runs its predicate (rule 9).
     - The **summary** $S_f(p)$ of a function $f$ is the set of type parameters whose symbolic labels the body's result carries at position $p$, on any return path, the labels that a raised program counter puts there included.
     - Over recursion, the summaries are the least fixpoint over each strongly connected component of the call graph: they start empty and grow until no body changes them.
     - A call raises each position $p$ by $\ell^{*}(\sigma(T))$ for each $T \in S_f(p)$ (`spec/10 §5`). A generic function used as a value does the same once its type arguments are known.
     - The summaries are inferred for every function, public ones included; `una contract` and `una report` show them (`spec/13 §5`, `§6`). Edition `0.1` raises every position by every type argument (D-137).
   - **Edition 0.1: decisions given to functions** (#253, #346, #350, #354). Edition `0.1` tells `ℓ*_T` from `ℓ_T` in its flows as edition `0.2` does (the two symbolic labels above; it has no result summaries), so a decided value flowing into an annotation `T`, a field `T` or a function value's parameter `T` is U4001 (#354; before, edition `0.1` read `ℓ*_T` as `ℓ_T`, and an annotation dropped the decision). The rules below remain, as defense in depth. A function value called with an argument that carries `ℓ*_T` raises the call's result and its program counter (T-App). A call of a function, the prelude's or a generic one, whose arguments carry `ℓ*_T` at any position and give it function values whose parameters do not accept it, may reveal the decision through what it returns, through its effects and through its failures, its own or the function values'. So its result is raised by that `ℓ*_T` at every position; it runs under that program counter, so its effects and the function values' are bounded by it and it may not fail (T-Call, U4002); and its failure is labeled by it, as an operation's is (rule 4). A function value accepts `ℓ*_T` only when it is a lambda written as the argument itself, inside parentheses or not, none of whose parameters is annotated, and every parameter's type carries that `ℓ*_T` (its types come from the data, as its body assumes them); every other function value accepts nothing: a named function value, a lambda with an annotated parameter, a lambda bound by `let`, wrapped in a branch, a block or a call, or held in a kind's field. This rejects some sound programs, such as a lambda whose annotated parameter receives no decision; write the lambda without annotations, or pass the decision explicitly. So `[if a == b then p else q].map(each: k)` with `k: fn(T) -> Int` is labeled `ℓ_T`, and writing it to a `public` sink is U4003, and `logger(if a == b then p else q, f: k)` with `logger` writing `f(x)` is U4002; edition `0.2` rejects these programs at the function argument (U4001).
   - **No effects or failures under a symbolic program counter.** Branching on a value whose label contains a symbolic label raises the program counter symbolically. Under such a program counter, capability operations, calls with effects and failures are U4002, because their sink constraint cannot be checked for every instantiation.
   - **Prelude results.** The prelude functions of `spec/14 §1` follow the same rule: a result that depends on element or argument values carries their labels. The structural functions put each label at the position that holds it, and the top label of the result only where the shape depends on it; the others label the whole result with the join of every label of their arguments and of their element types (`spec/14 §1` "Result labels", ADR 0051).
9. **Function parameters with `of` clauses** (v0.2, ADR 0062).
   - **In the callee.** Inside a function whose header names a parameter `p` in a `uses of` or `fails of` clause, a call of `p`, or passing `p` on, is allowed only under the function's public program counter (U4002 otherwise), since the sinks of `p` are not known there.
   - **At the call.** The body of a lambda given for such a parameter is checked under the program counter of the call, instead of the public one of a pure lambda (ADR 0031 rule 4).
   - **The prelude.** For the prelude's higher-order functions, that program counter is raised by what decides how often, and whether, the lambda runs:
     - the top label of `xs` for `map`, `filter` and `fold`, which call it once per element, in order;
     - for `first_where`, also the labels of the elements of `xs` and of `keep`'s result, since it stops at the first accepted element.
   - So `secret_list.map(each: fn(x) -> @console.print("item"))` is U4003: the number of lines printed reveals the length.
10. **Sites.** U4002 names the condition that raised the program counter as a related location. U4003 points at the argument that exceeds `accepts`, or at the operation when the program counter alone exceeds it.
