format.json

{
  "formatVersion": 5,
  "_header": "Extra header fields after the four fixed integers (magic, version, format digest, kernel schema, compiler identity), in declaration order. `string` is length-prefixed UTF-8. `app_id` is the app identity, reverse-DNS (LLP 1023 D5): bake writes it from DataSource::app_id(); empty is unnamed (a fixture or a stand-in) and unnamed matches anything at boot. LLP 1038 D2: router names the root slot filled before initializers.",
  "header": [
    {
      "name": "app_id",
      "codec": "string"
    },
    {
      "name": "router",
      "codec": "opt:slots"
    },
    {
      "name": "locale",
      "codec": "opt:slots",
      "_comment": "@ref LLP 1060 D4: the root string slot holding the resolved locale every `t(...)` reads; set only when the app calls `t`. The runner writes it from set_place."
    },
    {
      "name": "snapshot_entry",
      "codec": "string",
      "_comment": "LLP 1126 D2: empty for a running app, otherwise the snapshot entry kind; checked before decoding tables."
    },
    {
      "name": "snapshot_refresh",
      "codec": "opt:sources",
      "_comment": "LLP 1126.000 WP2: the snapshot refresh signature, number -> {date: number, props: Props}[]. Absent on a running app."
    }
  ],
  "_about": "The single declaration authority for the plan: its tables, the expression VM's opcodes, the stdlib roster, and the enum vocabularies. plan/build.rs generates the row structs, the canonical encoder, the validating decoder, the opcode and stdlib enums, and FORMAT_DIGEST from this file. Nothing here is hand-mirrored anywhere else. Kernel node types, props, and style rows are NOT declared here: plan rows carry the kernel's ordinals as numbers, and the crates that give them meaning take the vocabulary from exact-kernel (LLP 1004 D2).",
  "_codecs": "u8 | u16 | u32 | i32 | f64 | bool | str (u32 index into the string pool) | enum:<Name> (u8 ordinal) | idx:<table> (u32 row index, validated) | opt:<table> (u32 row index or NONE = 0xFFFFFFFF) | range:<table> (u32 start + u32 len, validated) | code (u32 offset + u32 len into the code pool, validated as well-formed bytecode) | bytes (u32 offset + u32 len into the data pool)",
  "_tables": "Document order is significant: nodes and regions with the same parent are ordered by `order`; an arm's content is every node and region whose `arm` names it; a node with no parent inside an arm is one of the arm's roots. A font face is one source path, a weight range (`weight` to `weight_max`; one weight is both), a stretch range in tenths of a percent (`stretch_min` to `stretch_max`; 1000 is normal width) and an italic flag, as an `@font-face` rule's descriptors. The compiler reads a range the declaration leaves unsaid from the file's `fvar` axes (LLP 1019 D2); a host never infers one.",
  "tables": [
    {
      "name": "types",
      "fields": [
        {
          "name": "kind",
          "codec": "enum:TypeKind"
        },
        {
          "name": "elem",
          "codec": "opt:types"
        },
        {
          "name": "fields",
          "codec": "range:fields"
        },
        {
          "name": "name",
          "codec": "str"
        }
      ]
    },
    {
      "name": "fields",
      "fields": [
        {
          "name": "name",
          "codec": "str"
        },
        {
          "name": "ty",
          "codec": "idx:types"
        }
      ]
    },
    {
      "name": "faces",
      "fields": [
        {
          "name": "source",
          "codec": "str"
        },
        {
          "name": "weight",
          "codec": "u16"
        },
        {
          "name": "weight_max",
          "codec": "u16"
        },
        {
          "name": "stretch_min",
          "codec": "u16"
        },
        {
          "name": "stretch_max",
          "codec": "u16"
        },
        {
          "name": "italic",
          "codec": "bool"
        }
      ]
    },
    {
      "name": "families",
      "fields": [
        {
          "name": "name",
          "codec": "str"
        },
        {
          "name": "faces",
          "codec": "range:faces"
        }
      ]
    },
    {
      "name": "stacks",
      "fields": [
        {
          "name": "members",
          "codec": "range:stack_members"
        }
      ]
    },
    {
      "name": "stack_members",
      "fields": [
        {
          "name": "kind",
          "codec": "enum:StackMemberKind"
        },
        {
          "name": "family",
          "codec": "opt:families"
        }
      ]
    },
    {
      "name": "slots",
      "fields": [
        {
          "name": "name",
          "codec": "str"
        },
        {
          "name": "ty",
          "codec": "idx:types"
        },
        {
          "name": "init",
          "codec": "code"
        },
        {
          "name": "owner",
          "codec": "opt:arms",
          "_comment": "@ref LLP 1017.000 (child state): the arm whose instance owns this slot — a `for` row, an `if` or `match` arm. The slot is created, its init evaluated in that arm's frames, when the arm instance is created, and dropped with it. None: a root slot."
        },
        {
          "name": "late",
          "codec": "bool",
          "_comment": "@ref LLP 1017.000 (child state): a root slot holding the state of a child used outside every region; its init runs once at the boot render, after boot settlement (so it may read derives and resources), not with the other root slots before it. Always false when owner is set."
        },
        {
          "name": "persist",
          "codec": "bool",
          "_comment": "@ref LLP 1116 D5 (`state ... persist`): a root slot the host keeps across launches. Boot takes the store's value under `exact.state.<name>` where it decodes to the slot's type (else the initializer's value stands, and the mismatch is journaled); after every commit that stands the store holds the slot's value. Only a root slot (no owner, not late) of a number, string or bool, or an option or list of those."
        }
      ]
    },
    {
      "name": "derives",
      "fields": [
        {
          "name": "name",
          "codec": "str"
        },
        {
          "name": "ty",
          "codec": "idx:types"
        },
        {
          "name": "body",
          "codec": "code"
        }
      ]
    },
    {
      "name": "resources",
      "fields": [
        {
          "name": "name",
          "codec": "str"
        },
        {
          "name": "source",
          "codec": "str"
        },
        {
          "name": "args",
          "codec": "range:args"
        },
        {
          "name": "context",
          "codec": "u16",
          "_comment": "@ref LLP 1027.005 D6: trailing request-context argument count; 0 without `with`. Only persisted kept-answer admission compares the identifying prefix. All live requests, compiled values, carry and document checkpoints compare every argument. Must not exceed args.len."
        },
        {
          "name": "ty",
          "codec": "idx:types"
        },
        {
          "name": "initial",
          "codec": "bytes"
        },
        {
          "name": "initial_args",
          "codec": "bytes"
        },
        {
          "name": "reader",
          "codec": "bool"
        },
        {
          "name": "placeholder",
          "codec": "opt:resources",
          "_comment": "@ref LLP 1048.003 D6: the row whose value shows while this one's source hasn't answered and nothing is kept for its arguments \u2014 a declared `else source(args)`, compiled as a row of its own (named `<name>#else`, arguments that read no state, the same type, no placeholder of its own). None: a list or an option shows its empty value, and anything else has none."
        },
        {
          "name": "placeholder_value",
          "codec": "bytes",
          "_comment": "@ref LLP 1054.000.002 D3: a declared `else empty(field=value, …)`, the compiler's constant (a value), shown while nothing is kept and the source has not answered. Empty bytes: none — an undeclared placeholder is the type's zero, which the runner computes (D1)."
        },
        {
          "name": "each",
          "codec": "range:args",
          "_comment": "@ref LLP 1017.000 P4c (amended 2026-11-04): empty for one request; for `resource r = source(args) for x in list [key=k] as shape S`, two entries: the list, read as a derive is, then the key, which reads the element as its one parameter (the element itself when no `key=` is written). `args` then read the element as their one parameter too; the source is asked once for each element, keyed as a `for` row is; `ty` is `S[]`, and each request answers `S`."
        }
      ]
    },
    {
      "name": "mutations",
      "fields": [
        {
          "name": "name",
          "codec": "str"
        },
        {
          "name": "slot",
          "codec": "idx:slots"
        },
        {
          "name": "ty",
          "codec": "idx:types"
        },
        {
          "name": "refreshes",
          "codec": "range:mutation_refreshes",
          "_comment": "@ref LLP 1054.000.000 D1: the resources a send to this mutation refreshes, forced, when it runs and when its reply lands (`mutation m as shape T refreshes a, b`)."
        },
        {
          "name": "then",
          "codec": "opt:actions",
          "_comment": "The action a `mutation … then action` runs after each answer lands, as its own commit (LLP 1016.001). None: nothing runs."
        },
        {
          "name": "queue",
          "codec": "bool",
          "_comment": "@ref LLP 1092 D1, D2: `mutation m as shape T queue` — one send in flight; a later send waits, with its send-time arguments, until the one before it is answered or let go and its `then` has run. False: the newest send wins (LLP 1016 §4)."
        }
      ]
    },
    {
      "name": "mutation_refreshes",
      "fields": [
        {
          "name": "resource",
          "codec": "idx:resources"
        }
      ]
    },
    {
      "name": "args",
      "fields": [
        {
          "name": "expr",
          "codec": "code"
        }
      ]
    },
    {
      "name": "sources",
      "fields": [
        {
          "name": "name",
          "codec": "str"
        },
        {
          "name": "params",
          "codec": "range:source_params"
        },
        {
          "name": "ty",
          "codec": "idx:types"
        }
      ]
    },
    {
      "name": "modules",
      "_comment": "LLP 1133.002 D13, LLP 1124 D5: the sources that are a native module's names, which the runner routes to the native slot rather than the app's data. `declared` and `extension` are what the wire carries; `request` is `always`, `when-prompt` or `never`; `sync` is the synchronous form's name, or empty; `substitute` is what the agent's runner answers with no implementation bound (LLP 1133.002 §6), a JSON object.",
      "fields": [
        {
          "name": "source",
          "codec": "idx:sources"
        },
        {
          "name": "extension",
          "codec": "str"
        },
        {
          "name": "declared",
          "codec": "str"
        },
        {
          "name": "send",
          "codec": "bool"
        },
        {
          "name": "live",
          "codec": "bool"
        },
        {
          "name": "request",
          "codec": "str"
        },
        {
          "name": "sync",
          "codec": "str"
        },
        {
          "name": "substitute",
          "codec": "str"
        }
      ]
    },
    {
      "name": "module_events",
      "_comment": "LLP 1133.004 D6: a native module's event the app's root hears, and the action it runs with the event's arguments, as many as the action takes. `raised` is `activation` (a person's act on the platform's UI, which only the host raises), `emit` (the device's) or `wake` (LLP 1133.017 D5: the host's alone, at the platform's call, each an invocation of a wake); `hold` bounds the deliveries held before the session can hear them; `budget` is a wake event's milliseconds from the wake's first delivery to its deadline, 0 for any other.",
      "fields": [
        {
          "name": "extension",
          "codec": "str"
        },
        {
          "name": "declared",
          "codec": "str"
        },
        {
          "name": "action",
          "codec": "idx:actions"
        },
        {
          "name": "raised",
          "codec": "str"
        },
        {
          "name": "hold",
          "codec": "u32"
        },
        {
          "name": "budget",
          "codec": "u32"
        }
      ]
    },
    {
      "name": "tools",
      "_comment": "LLP 1111 D2, LLP 1133.023 D7: a root action offered to a caller that is not the person. `consequence` is `reads`, `writes` or `destroys`; `returns`, `fails` and `available` are the derives holding the line's clauses; `face` is the manifest's `intents` face for it as a JSON object, or empty for a tool with none.",
      "fields": [
        {
          "name": "name",
          "codec": "str"
        },
        {
          "name": "consequence",
          "codec": "str"
        },
        {
          "name": "additive",
          "codec": "bool"
        },
        {
          "name": "idempotent",
          "codec": "bool"
        },
        {
          "name": "closed",
          "codec": "bool"
        },
        {
          "name": "description",
          "codec": "str"
        },
        {
          "name": "action",
          "codec": "idx:actions"
        },
        {
          "name": "returns",
          "codec": "opt:derives"
        },
        {
          "name": "fails",
          "codec": "opt:derives"
        },
        {
          "name": "available",
          "codec": "opt:derives"
        },
        {
          "name": "face",
          "codec": "str"
        }
      ]
    },
    {
      "name": "source_params",
      "fields": [
        {
          "name": "ty",
          "codec": "idx:types"
        }
      ]
    },
    {
      "name": "actions",
      "fields": [
        {
          "name": "name",
          "codec": "str"
        },
        {
          "name": "params",
          "codec": "range:params"
        },
        {
          "name": "writes",
          "codec": "range:writes"
        },
        {
          "name": "body",
          "codec": "code"
        }
      ]
    },
    {
      "name": "params",
      "fields": [
        {
          "name": "name",
          "codec": "str"
        },
        {
          "name": "ty",
          "codec": "idx:types"
        }
      ]
    },
    {
      "name": "writes",
      "fields": [
        {
          "name": "slot",
          "codec": "idx:slots"
        }
      ]
    },
    {
      "name": "timers",
      "fields": [
        { "name": "wait", "codec": "u8" },
        { "name": "max_ms", "codec": "u32" },
        { "name": "tolerance_ms", "codec": "u32" },
        {
          "name": "interval_ms",
          "codec": "u32"
        },
        {
          "name": "action",
          "codec": "idx:actions"
        },
        {
          "name": "once",
          "codec": "bool"
        },
        {
          "name": "frame",
          "codec": "bool"
        },
        {
          "name": "name",
          "codec": "str",
          "_comment": "The task's name, for the agent's `state.tasks` (LLP 1092 D10)."
        },
        {
          "name": "gated",
          "codec": "bool",
          "_comment": "@ref LLP 1092 D7, D8: `task t when cond`: the timer is armed while `gate` is true and idle (an infinite deadline) while it is false. False: `mount`, armed from boot."
        },
        {
          "name": "gate",
          "codec": "code",
          "_comment": "@ref LLP 1092 D9: the gate, a bool, evaluated at each commit after its settlement; the constant `true` for an ungated task."
        },
        {
          "name": "keyed",
          "codec": "bool",
          "_comment": "@ref LLP 1092 D7, D8: `key=expr`: a changed key (compared as a `for` key is) re-arms the timer from the commit's time."
        },
        {
          "name": "key",
          "codec": "code",
          "_comment": "@ref LLP 1092 D9: the key, a string, number or bool; the constant `true` when not keyed."
        }
      ]
    },
    {
      "name": "sequences",
      "_comment": "@ref LLP 1125 D2, D3: each `sequence NAME when gate key=key` and its `play(tracks, bpm=, from=, countIn=, clock=, clockOut=, ended=)`. The gate and key are a task's (LLP 1092 D9); the arguments are plan code the runner evaluates after each commit's settlement and compares by value. An omitted argument is a constant: `from` 0, `countIn` [], `clock` and `clockOut` \"\".",
      "fields": [
        {
          "name": "name",
          "codec": "str"
        },
        {
          "name": "gated",
          "codec": "bool"
        },
        {
          "name": "gate",
          "codec": "code"
        },
        {
          "name": "keyed",
          "codec": "bool"
        },
        {
          "name": "key",
          "codec": "code"
        },
        {
          "name": "tracks",
          "codec": "code"
        },
        {
          "name": "bpm",
          "codec": "code"
        },
        {
          "name": "from",
          "codec": "code"
        },
        {
          "name": "count_in",
          "codec": "code"
        },
        {
          "name": "clock",
          "codec": "code"
        },
        {
          "name": "clock_out",
          "codec": "code"
        },
        {
          "name": "ended",
          "codec": "opt:actions"
        }
      ]
    },
    {
      "name": "regions",
      "fields": [
        {
          "name": "kind",
          "codec": "enum:RegionKind"
        },
        {
          "name": "parent",
          "codec": "opt:nodes"
        },
        {
          "name": "arm",
          "codec": "opt:arms"
        },
        {
          "name": "order",
          "codec": "u32"
        },
        {
          "name": "subject",
          "codec": "code"
        },
        {
          "name": "key",
          "codec": "code"
        },
        {
          "name": "arms",
          "codec": "range:arms"
        }
      ]
    },
    {
      "name": "arms",
      "fields": [
        {
          "name": "region",
          "codec": "idx:regions"
        }
      ]
    },
    {
      "name": "surface_args",
      "fields": [
        {
          "name": "name",
          "codec": "str"
        },
        {
          "name": "expr",
          "codec": "code"
        }
      ]
    },
    {
      "name": "surfaces",
      "fields": [
        {
          "name": "mode",
          "codec": "enum:SurfaceArgsMode"
        },
        {
          "name": "name",
          "codec": "str"
        },
        {
          "name": "args",
          "codec": "range:surface_args"
        }
      ]
    },
    {
      "name": "nodes",
      "fields": [
        {
          "name": "node_type",
          "codec": "u8"
        },
        {
          "name": "parent",
          "codec": "opt:nodes"
        },
        {
          "name": "arm",
          "codec": "opt:arms"
        },
        {
          "name": "order",
          "codec": "u32"
        },
        {
          "name": "bindings",
          "codec": "range:bindings"
        },
        {
          "name": "handlers",
          "codec": "range:handlers"
        },
        {
          "name": "surface",
          "codec": "opt:surfaces"
        }
      ]
    },
    {
      "name": "activity_slots",
      "_comment": "LLP 1126.001 WP8: independent placement roots in one snapshot session; no refresh. Names are lockScreen, compactLeading, compactTrailing, minimal, expanded.leading, expanded.trailing, expanded.center and expanded.bottom.",
      "fields": [
        {
          "name": "name",
          "codec": "str"
        },
        {
          "name": "root",
          "codec": "idx:nodes"
        }
      ]
    },
    {
      "name": "bindings",
      "fields": [
        {
          "name": "kind",
          "codec": "enum:BindingKind"
        },
        {
          "name": "id",
          "codec": "u16"
        },
        {
          "name": "expr",
          "codec": "code"
        },
        {
          "name": "written",
          "codec": "bool",
          "_comment": "@ref LLP 1115.000 D2: whether the author wrote this row on this node: an attribute of the node, or a row of a `style` its `class` names. False for a row the compiler implies (a tag's fixed row, a heading's size and weight, a link run's colour, a sheet's rows, a row derived from another). Set where lowering emits the row; where two rows set one property, the winner's. The runner hands a style row's to the kernel, which keeps it beside the row (`StyleProps::written`); a prop row's is carried and read by nothing yet."
        }
      ]
    },
    {
      "name": "looks",
      "_comment": "@ref LLP 1121 D8 (stage 8 A; amended 2026-10-18): a `:hover` or `:focus-visible` look on a node `node` (rows in node order, at most one a state a node; a node with none has no row, so a plan without state parts pays nothing), which the host applies on its own tracking with no round trip (LLP 1061 D1's reason): `state` 1 `:hover`, 2 `:focus-visible` (0, once `:active`, is retired and refused: `:active` lowers to the press paint, LLP 1061 D7); `bindings` its style rows, each a literal (a token's name is one, as a static row's): `background-color`, a side's `border-*-color`, `opacity`, `box-shadow`. A host composes them over the base, `:hover` then `:focus-visible`, under the press paint; a disabled node takes none.",
      "fields": [
        {
          "name": "node",
          "codec": "idx:nodes"
        },
        {
          "name": "state",
          "codec": "u8"
        },
        {
          "name": "bindings",
          "codec": "range:bindings"
        }
      ]
    },
    {
      "name": "handlers",
      "fields": [
        {
          "name": "event",
          "codec": "enum:EventKind"
        },
        {
          "name": "action",
          "codec": "idx:actions"
        },
        {
          "name": "args",
          "codec": "range:args"
        }
      ]
    },
    {
      "name": "routes",
      "fields": [
        {
          "name": "name",
          "codec": "str"
        },
        {
          "name": "pattern",
          "codec": "str"
        },
        {
          "name": "parent",
          "codec": "opt:routes"
        },
        {
          "name": "tab",
          "codec": "bool"
        },
        {
          "name": "notfound",
          "codec": "bool"
        },
        {
          "name": "render",
          "codec": "enum:RenderPolicy",
          "_comment": "@ref LLP 1048 D2, LLP 1048.003 D5: when the route's document renders; undeclared is client."
        },
        {
          "name": "activate",
          "codec": "enum:ActivatePolicy",
          "_comment": "@ref LLP 1048.003 D5: when a rendered page's runtime loads; inferred when undeclared."
        },
        {
          "name": "paint",
          "codec": "enum:PaintPolicy",
          "_comment": "@ref LLP 1048.005: what a served page's reader sees first; `settled` (undeclared) is the settled page, `boot` the boot document, sent before any answer, then the settled page."
        },
        {
          "name": "pages",
          "codec": "str",
          "_comment": "@ref LLP 1048.000 D2, LLP 1048.003 D5: the source that lists a parameterized route's pages \u2014 the values of its one parameter, a list<string> \u2014 for the build to render and the server's sitemap to name. Empty: none."
        },
        {
          "name": "pages_args",
          "codec": "bytes",
          "_comment": "@ref LLP 1048.000 D2: that source's arguments, values (a list in the plan's value encoding); empty bytes without a source."
        }
      ]
    },
    {
      "name": "keyframes",
      "_comment": "@ref LLP 1055 D5: the app's `@keyframes` rules by name, each body as CSS text (`0%{r:3px;}100%{r:9px;}`); the runner resolves `animation-name` against them.",
      "fields": [
        {
          "name": "name",
          "codec": "str"
        },
        {
          "name": "css",
          "codec": "str"
        }
      ]
    },
    {
      "name": "sounds",
      "_comment": "@ref LLP 1096 D1: each declared sound, a WAV the compiler read: its app-relative path (what `playSound` names), its length in frames at its own rate, its channels, and the SHA-256 of its bytes as hex. The runner reads a voice's natural length, frames / rate; the hosts read which files to decode.",
      "fields": [
        {
          "name": "src",
          "codec": "str"
        },
        {
          "name": "frames",
          "codec": "u32"
        },
        {
          "name": "rate",
          "codec": "u32"
        },
        {
          "name": "channels",
          "codec": "u8"
        },
        {
          "name": "digest",
          "codec": "str"
        }
      ]
    },
    {
      "name": "profiles",
      "_comment": "@ref LLP 1100 D3: the app's `@color-profile`s by name: the ICC file (an asset path) and the rendering intent; `color(--name …)` resolves against them, and the platform draws it.",
      "fields": [
        {
          "name": "name",
          "codec": "str"
        },
        {
          "name": "src",
          "codec": "str"
        },
        {
          "name": "intent",
          "codec": "str"
        }
      ]
    },
    {
      "name": "theme",
      "_comment": "@ref LLP 1095 D4: the app's `theme`, one row an entry: its name, the role it overrides as a row writes it (`-exact-secondary-label`, `Canvas`; empty for none), the text it stands for, which names no entry, and its kind. A string row naming an entry of its kind or an overridden role reads that text, in the compiler and when the runner sets a row.",
      "fields": [
        {
          "name": "name",
          "codec": "str"
        },
        {
          "name": "role",
          "codec": "str"
        },
        {
          "name": "value",
          "codec": "str"
        },
        {
          "name": "kind",
          "codec": "u8",
          "_comment": "@ref LLP 1121 D3, D7: the token's kind, which rows may name it: 0 a colour, 1 a length (px text, one `rem` or `em`, or a named length), 2 a number, 3 a `box-shadow`, 4 a `text-shadow` (the row's own text, its colours folded). A string row reads an entry of its row's kind; `value` and the slices are its text in that kind."
        },
        {
          "name": "slices",
          "codec": "range:theme_slices",
          "_comment": "@ref LLP 1121 D5, D7: a token that varies by an app axis has one slice per full app tuple, in tuple order (mixed radix over `axes`, the first axis most significant); `value` is the default tuple's. Empty for a token that does not vary."
        }
      ]
    },
    {
      "name": "theme_slices",
      "_comment": "@ref LLP 1121 D5: one token's text for one full app tuple; a `theme` row's `slices` range names its own.",
      "fields": [
        {
          "name": "value",
          "codec": "str"
        }
      ]
    },
    {
      "name": "axes",
      "_comment": "@ref LLP 1121 D5: the app's axes in declaration order, each with its values joined by `|`, the first the default. `-exact-mode` pins a node's value per axis; the window's are `setMode`'s.",
      "fields": [
        {
          "name": "name",
          "codec": "str"
        },
        {
          "name": "values",
          "codec": "str"
        }
      ]
    },
    {
      "name": "icons",
      "_comment": "@ref LLP 1121 D10 (stage 6 F): each icon token the plan keeps, which a computed `symbol:` source may name (`symbol:icon.reply`, or `symbol:sf/<name>` for the icon whose `sf` it is): its SF Symbol (empty for none), the SVG's viewBox and its paths' `d` joined by `;`, drawn as a template as a role's path is (empty for a file the web draws as written), and the SVG's path under `assets/` (empty for none). A literal source is written at build as `symbol:icon|<sf>|<view_box>|<path>|<svg>`, the image source form hosts read (`exact_kernel::Icon`): `<path>` is each SVG path's `d` joined by `;`, each filled nonzero; no part holds a `|`, which the build refuses.",
      "fields": [
        {
          "name": "name",
          "codec": "str"
        },
        {
          "name": "sf",
          "codec": "str"
        },
        {
          "name": "view_box",
          "codec": "str"
        },
        {
          "name": "path",
          "codec": "str"
        },
        {
          "name": "svg",
          "codec": "str"
        }
      ]
    },
    {
      "name": "hatches",
      "_comment": "@ref LLP 1075.003.000.001 §4.3: each hatch word app.json declares, with the platforms whose module handles it as a mask (bit 0 ios, 1 tvos, 2 macos, 3 web, 4 linux, 5 windows, 6 android; a plain list is every bit). A host calls a word only where its bit is set, so a platform taken off a word stops being called with the next bundle.",
      "fields": [
        {
          "name": "word",
          "codec": "str"
        },
        {
          "name": "platforms",
          "codec": "u16"
        }
      ]
    },
    {
      "name": "views",
      "_comment": "@ref LLP 1133.001 D1, LLP 1133.008 D8 items 1 and 2: each custom-element tag the app's views place that a package serves rather than the app's own module, with the extension whose implementation makes it in each session. `displayed`: the runner reports each instance's displayed state to that implementation, with the origin of the commit that changed it; `binds`: the props, by name separated by spaces, whose changes it reports the same way.",
      "fields": [
        {
          "name": "tag",
          "codec": "str"
        },
        {
          "name": "extension",
          "codec": "str"
        },
        {
          "name": "displayed",
          "codec": "bool"
        },
        {
          "name": "binds",
          "codec": "str"
        }
      ]
    },
    {
      "name": "texts",
      "_comment": "@ref LLP 1060 D3: one localized text, `{name}` placeholders unfilled. Within a locale, sorted by key.",
      "fields": [
        {
          "name": "key",
          "codec": "str"
        },
        {
          "name": "text",
          "codec": "str"
        }
      ]
    },
    {
      "name": "locales",
      "_comment": "@ref LLP 1060 D3: one strings table per locale (BCP 47 name). Row 0 is the base; the rest are in name order. rtl is the CLDR script direction, compiled once. Table names remain for data-only strings. Only the keys the app's `t` calls name.",
      "fields": [
        {
          "name": "name",
          "codec": "str"
        },
        {
          "name": "rtl",
          "codec": "bool"
        },
        {
          "name": "texts",
          "codec": "range:texts"
        }
      ]
    }
  ],
  "_enums": "Wire ordinal is the 0-based index. An unknown ordinal is a typed decode rejection.",
  "enums": {
    "SurfaceArgsMode": ["named", "positional"],
    "TypeKind": [
      "number",
      "bool",
      "string",
      "unit",
      "option",
      "list",
      "record"
    ],
    "RegionKind": [
      "when",
      "match",
      "each"
    ],
    "BindingKind": [
      "prop",
      "style"
    ],
    "RenderPolicy": [
      "client",
      "build",
      "cached",
      "request"
    ],
    "ActivatePolicy": [
      "inferred",
      "idle",
      "never",
      "interaction"
    ],
    "PaintPolicy": [
      "settled",
      "boot"
    ],
    "StackMemberKind": [
      "family",
      "system-ui",
      "ui-sans-serif",
      "sans-serif",
      "ui-serif",
      "serif",
      "ui-monospace",
      "monospace",
      "ui-rounded"
    ],
    "EventKind": [
      "press",
      "change",
      "hover",
      "focus",
      "blur",
      "key",
      "submit",
      "load",
      "message",
      "contextmenu",
      "dblclick",
      "swiperight",
      "scroll",
      "navigate",
      "heightrelease",
      "transformgeometry",
      "transformrelease",
      "reorderdrop",
      "reachstart",
      "reachend",
      "loadedmetadata",
      "durationchange",
      "timeupdate",
      "play",
      "playing",
      "pause",
      "ended",
      "waiting",
      "seeking",
      "seeked",
      "ratechange",
      "volumechange",
      "error",
      "canplay",
      "pan",
      "select",
      "refresh",
      "input",
      "cancel",
      "panrelease",
      "pointerdown",
      "pointerup",
      "pointermove",
      "copy",
      "cut",
      "paste",
      "selectionchange",
      "beforeunload",
      "wheel",
      "drop",
      "resize",
      "seekbackward",
      "seekforward",
      "seekto",
      "previoustrack",
      "nexttrack",
      "stop",
      "fullscreenchange",
      "keyup",
      "keycapture",
      "intersect",
      "focusin",
      "focusout",
      "close",
      "toggle",
      "scrollend",
      "beforeinput",
      "midimessage",
      "dragenter",
      "dragleave",
      "currententrychange",
      "navigatesuccess",
      "navigateerror",
      "atompress",
      "newwindow",
      "download",
      "capture",
      "userpromptopened",
      "enterpictureinpicture",
      "leavepictureinpicture",
      "pictureinpictureerror",
      "historyswipe"
    ]
  },
  "_opcodes": "The expression VM: a stack machine over values with a small locals stack (`BindLocal` pops into it, `LoadLocal` copies from it, `DropLocal` pops it) for names an inline `match` binds and the item and index a `Map`/`Filter` callback binds. Each opcode names its operand layout; the decoder validates framing and every index operand. `depth` operands count enclosing instance scopes (0 = innermost). Type inference guarantees stack discipline; the VM still traps, never UB.",
  "opcodes": [
    {
      "name": "Number",
      "operands": [
        "f64"
      ]
    },
    {
      "name": "Bool",
      "operands": [
        "u8"
      ]
    },
    {
      "name": "Str",
      "operands": [
        "str"
      ]
    },
    {
      "name": "None",
      "operands": []
    },
    {
      "name": "Unit",
      "operands": []
    },
    {
      "name": "Some",
      "operands": []
    },
    {
      "name": "LoadSlot",
      "operands": [
        "idx:slots"
      ]
    },
    {
      "name": "LoadDerive",
      "operands": [
        "idx:derives"
      ]
    },
    {
      "name": "LoadResource",
      "operands": [
        "idx:resources"
      ]
    },
    {
      "name": "LoadParam",
      "operands": [
        "u16"
      ]
    },
    {
      "name": "LoadItem",
      "operands": [
        "u16"
      ]
    },
    {
      "name": "LoadBound",
      "operands": [
        "u16"
      ]
    },
    {
      "name": "Field",
      "operands": [
        "u16"
      ]
    },
    {
      "name": "Record",
      "operands": [
        "idx:types"
      ]
    },
    {
      "name": "List",
      "operands": [
        "u32"
      ]
    },
    {
      "name": "Add",
      "operands": []
    },
    {
      "name": "Sub",
      "operands": []
    },
    {
      "name": "Mul",
      "operands": []
    },
    {
      "name": "Div",
      "operands": []
    },
    {
      "name": "Rem",
      "operands": []
    },
    {
      "name": "Neg",
      "operands": []
    },
    {
      "name": "Eq",
      "operands": []
    },
    {
      "name": "Ne",
      "operands": []
    },
    {
      "name": "Lt",
      "operands": []
    },
    {
      "name": "Le",
      "operands": []
    },
    {
      "name": "Gt",
      "operands": []
    },
    {
      "name": "Ge",
      "operands": []
    },
    {
      "name": "Not",
      "operands": []
    },
    {
      "name": "Concat",
      "operands": []
    },
    {
      "name": "Jump",
      "operands": [
        "u32"
      ]
    },
    {
      "name": "JumpIfFalse",
      "operands": [
        "u32"
      ]
    },
    {
      "name": "JumpIfNone",
      "operands": [
        "u32"
      ]
    },
    {
      "name": "Unwrap",
      "operands": []
    },
    {
      "name": "Call",
      "operands": [
        "enum:Stdlib"
      ]
    },
    {
      "name": "StoreSlot",
      "operands": [
        "idx:slots"
      ]
    },
    {
      "name": "Command",
      "operands": [
        "str",
        "u16"
      ]
    },
    {
      "name": "Pop",
      "operands": []
    },
    {
      "name": "BindLocal",
      "operands": []
    },
    {
      "name": "LoadLocal",
      "operands": [
        "u16"
      ]
    },
    {
      "name": "DropLocal",
      "operands": []
    },
    {
      "name": "Return",
      "operands": []
    },
    {
      "name": "Send",
      "operands": [
        "idx:mutations",
        "str",
        "u16"
      ]
    },
    {
      "name": "Refresh",
      "operands": [
        "idx:resources"
      ]
    },
    {
      "name": "PendingResource",
      "operands": [
        "idx:resources"
      ]
    },
    {
      "name": "PendingMutation",
      "operands": [
        "idx:mutations"
      ]
    },
    {
      "name": "FailedResource",
      "operands": [
        "idx:resources"
      ]
    },
    {
      "name": "NativeProps",
      "operands": [
        "u32"
      ]
    },
    {
      "name": "LoadIndex",
      "operands": [
        "u16"
      ],
      "_comment": "LLP 1062 D8: the position (a number from 0) of the `for` row `depth` scopes out, as `for item, i in list` names it."
    },
    {
      "name": "Map",
      "operands": [
        "u32"
      ],
      "_comment": "@ref LLP 1017.003 D5: pops a list; runs the callback body that follows inline up to the operand's offset once per item, with the item and its index bound as the next two locals; pushes the list of the values the body leaves."
    },
    {
      "name": "Filter",
      "operands": [
        "u32"
      ],
      "_comment": "@ref LLP 1017.003 D5: as `Map`, keeping each item whose body leaves `true`."
    },
    {
      "name": "FailureResource",
      "operands": [
        "idx:resources"
      ],
      "_comment": "@ref LLP 1109 D3: `failure(x)`: once the resource settled, `none` while its latest request for its current arguments has not failed, else `some` of the compiler's `Failure` record, `{ code, message }` by position."
    },
    { "name": "FailedMutation", "operands": ["idx:mutations"] },
    { "name": "FailureMutation", "operands": ["idx:mutations"] }
  ],
  "_stdlib": "The enumerated roster (LLP 1004 D2/D4): every callable an expression may name, with its parameter types and return type (`any` = one of number, string, bool, list). The compiler checks calls against this table; the runner's VM implements each entry once; entries are added by fixture, never by speculation. LLP 1038 D3: Router and Entry name reserved record shapes; list<Router>, list<Entry>, and list<string> are typed lists.",
  "stdlib": [
    {
      "name": "performanceNow",
      "params": [],
      "returns": "number",
      "_comment": "@ref LLP 1109 D1: the web's `performance.now()`: milliseconds on the runner's monotonic clock since boot (the driver's clock under the agent, from 0), not the date. Renamed from `now()`, which is refused (`type-now-renamed`)."
    },
    {
      "name": "formatTime",
      "params": ["number", "number", "\"short\""],
      "returns": "string",
      "_comment": "@ref LLP 1054.000.003 D1/D7: `h:mm AM` of (epochMs, utcOffset minutes east), as Intl.DateTimeFormat(\"en-US\", { timeZone: <the offset>, timeStyle: \"short\" }) prints it. Core: every app links it, as it linked formatClockTime. A parameter spelled as string literals (`\"a\" | \"b\"`) is a string the compiler requires written as one of them."
    },
    {
      "name": "length",
      "params": [
        "any"
      ],
      "returns": "number"
    },
    {
      "name": "isEmpty",
      "params": [
        "any"
      ],
      "returns": "bool"
    },
    {
      "name": "toString",
      "params": [
        "any"
      ],
      "returns": "string"
    },
    {
      "name": "floor",
      "params": [
        "number"
      ],
      "returns": "number"
    },
    {
      "name": "max",
      "params": [
        "number",
        "number"
      ],
      "returns": "number"
    },
    {
      "name": "min",
      "params": [
        "number",
        "number"
      ],
      "returns": "number"
    },
    {
      "name": "open",
      "params": [
        "Router",
        "string"
      ],
      "returns": "Router"
    },
    {
      "name": "push",
      "params": [
        "Router",
        "string"
      ],
      "returns": "Router"
    },
    {
      "name": "replace",
      "params": [
        "Router",
        "string"
      ],
      "returns": "Router"
    },
    {
      "name": "back",
      "params": [
        "Router"
      ],
      "returns": "Router"
    },
    {
      "name": "select",
      "params": [
        "Router",
        "string"
      ],
      "returns": "Router"
    },
    {
      "name": "go",
      "params": [
        "Router",
        "string"
      ],
      "returns": "Router"
    },
    {
      "name": "stack",
      "params": [
        "Router"
      ],
      "returns": "list<Entry>"
    },
    {
      "name": "top",
      "params": [
        "Router"
      ],
      "returns": "Entry"
    },
    {
      "name": "depth",
      "params": [
        "Router"
      ],
      "returns": "number"
    },
    {
      "name": "params",
      "params": [
        "Router",
        "string"
      ],
      "returns": "list<string>"
    },
    {
      "name": "searchParam",
      "params": [
        "Entry",
        "string"
      ],
      "returns": "string"
    },
    {
      "name": "encodeURIComponent",
      "params": [
        "string"
      ],
      "returns": "string"
    },
    {
      "name": "encodeRouteSegment",
      "params": [
        "string"
      ],
      "returns": "string"
    },
    {
      "name": "includes",
      "params": ["any", "any"],
      "returns": "bool",
      "_comment": "The web's `String.prototype.includes(needle)`: a case-sensitive literal substring search; the empty needle matches. @ref LLP 1088 §9.1: over a list of strings, numbers or bools, `Array.prototype.includes(item)` (SameValueZero: NaN is NaN, -0 is 0), one list step per item scanned up to the match. `any` is the type checker's. The web's optional position argument is not taken."
    },
    {
      "name": "trim",
      "params": ["string"],
      "returns": "string",
      "_comment": "@ref LLP 1054.000.005 D1: JavaScript's String.prototype.trim — ECMA-262 WhiteSpace and LineTerminator, not Rust's White_Space."
    },
    {
      "name": "first",
      "params": ["any"],
      "returns": "any",
      "_comment": "@ref LLP 1054.000 C4: a list's first item, `some(x)`, or `none` for an empty list; `any` is `list<T>` in and `option<T>` out (the type checker's)."
    },
    {
      "name": "t",
      "params": ["string", "string", "list<string>"],
      "returns": "string",
      "_comment": "@ref LLP 1060 D2: the text for (locale, key), placeholders filled from name/value pairs. The compiler writes every argument; an author writes `t(\"key\", name=value)`."
    },
    {
      "name": "map",
      "params": ["any", "any"],
      "returns": "any",
      "_comment": "@ref LLP 1017.003 D4: `map(list<T>, (T, number) => U) -> list<U>` (the type checker's). Lowered to the `Map` opcode, never `Call`: the row reserves the name."
    },
    {
      "name": "filter",
      "params": ["any", "any"],
      "returns": "any",
      "_comment": "@ref LLP 1017.003 D4: `filter(list<T>, (T, number) => bool) -> list<T>`. Lowered to the `Filter` opcode, never `Call`."
    },
    {
      "name": "join",
      "params": ["any", "string"],
      "returns": "string",
      "_comment": "@ref LLP 1017.003 D4: the web's `Array.prototype.join` over a list of strings, numbers or bools, each printed as `toString` prints it."
    },
    {
      "name": "formatDate",
      "params": ["number", "number", "\"medium\" | \"month-year\" | \"iso\""],
      "returns": "string",
      "_comment": "@ref LLP 1054.000.003 D2/D7/D8: the calendar date of (epochMs, utcOffset), as Intl.DateTimeFormat(\"en-US\") prints it: `medium` is { dateStyle: \"medium\" }, `month-year` is { month: \"long\", year: \"numeric\" }. @ref LLP 1102 §3.4: `iso` is `YYYY-MM-DD`, the date at that wall time: `Date.prototype.toISOString`'s date part at a whole-minute offset (a fractional offset's wall time is not clipped to a millisecond again, as no style's is); outside years 1–9999 it prints `\"\"`, as every style does (D7). The linked capability `format`."
    },
    {
      "name": "formatNumber",
      "params": ["number", "\"compact\" | \"decimal\" | \"currency\" | \"percent\"", "\"USD\" | \"EUR\" | \"GBP\" | \"JPY\" | \"CNY\" | \"INR\" | \"CAD\" | \"AUD\" | \"NZD\" | \"HKD\" | \"SGD\" | \"CHF\" | \"SEK\" | \"NOK\" | \"DKK\" | \"PLN\" | \"MXN\" | \"BRL\" | \"KRW\" | \"ZAR\" | \"TWD\" | \"ILS\" | \"PHP\" | \"VND\""],
      "optional": ["\"\""],
      "returns": "string",
      "_comment": "@ref LLP 1054.000.003 D3/D7/D8: `compact` is Intl.NumberFormat(\"en-US\", { notation: \"compact\", roundingMode: \"trunc\", signDisplay: \"negative\" }). @ref LLP 1116 D8: `decimal` is Intl.NumberFormat(\"en-US\") (grouped, at most three fraction digits), `currency` with an ISO 4217 code { style: \"currency\", currency } (`$1,481.47`, `-$5.00`, the code's own fraction digits), `percent` { style: \"percent\" } (`26%`): each rounds the value's shortest decimal digits half away from zero, as ICU does, and signs a negative zero. The code is written only with `currency`, and the compiler fills `\"\"` for a call that omits it. Every style prints `\"\"` for a non-finite value (D7). The linked capability `format`."
    },
    {
      "name": "frame",
      "params": ["string"],
      "returns": "Geometry",
      "_comment": "@ref LLP 1051.000 D1/D2: where layout put the first node whose `id` prop is the argument, as last laid out: its border box in its root's space, free of transforms and scrolling. Actions only (the compiler refuses it elsewhere)."
    },
    {
      "name": "measure",
      "params": ["string"],
      "returns": "Geometry",
      "_comment": "@ref LLP 1051.000 D1/D2: the node's border box as if its `height` were `auto`, under the offer it has now. Actions only; the id is a string literal, so the runner answers it before the action runs."
    },
    {
      "name": "at",
      "params": ["any", "number"],
      "returns": "any",
      "_comment": "@ref LLP 1006 §3: JavaScript's Array.prototype.at — `some` of the item at an index truncated toward zero, counted from the end when negative, `none` past either end; `any` is `list<T>` in and `option<T>` out (the type checker's)."
    },
    {
      "name": "startsWith",
      "params": ["string", "string"],
      "returns": "bool",
      "_comment": "The web's `String.prototype.startsWith(prefix)`: whether the text begins with the prefix, case-sensitive; the empty prefix matches. The web's optional position argument is not taken."
    },
    {
      "name": "endsWith",
      "params": ["string", "string"],
      "returns": "bool",
      "_comment": "The web's `String.prototype.endsWith(suffix)`: whether the text ends with the suffix, case-sensitive; the empty suffix matches. The web's optional end-position argument is not taken."
    },
    {
      "name": "slice",
      "params": ["any", "number", "number"],
      "optional": ["Number.MAX_VALUE"],
      "returns": "any",
      "_comment": "@ref LLP 1088 D2: JavaScript's `String.prototype.slice(start, end?)` over UTF-16 code units (ToIntegerOrInfinity: NaN is 0, fractions truncate, a negative index counts from the end, both clamped); an omitted `end` is `Number.MAX_VALUE`, which clamps as `undefined` does (a plan's constants are finite, so not `Infinity`). The result is made well formed: a lone surrogate half becomes U+FFFD. @ref LLP 1088 §9.1: over a list, `Array.prototype.slice(start, end?)` by the same clamp, one list step per item kept, the result's extent checked as a `List` is; `any` is `string` or `list<T>` in and the same out (the type checker's)."
    },
    {
      "name": "replaceAll",
      "params": ["string", "string", "string"],
      "returns": "string",
      "_comment": "@ref LLP 1088 D2: JavaScript's `String.prototype.replaceAll(find, with)` with a string `find`: every match, left to right, `GetSubstitution` applied (`$$`, `$&`, `` $` ``, `$'`; `$1` is literal), an empty `find` inserting at every code-unit boundary; the whole result made well formed once, and bounded by `MAX_STRING` UTF-8 bytes as it is built."
    },
    {
      "name": "toLowerCase",
      "params": ["string"],
      "returns": "string",
      "_comment": "@ref LLP 1088 D2: JavaScript's `String.prototype.toLowerCase()`: Unicode's default, locale-independent mapping with final sigma. Linked by use: it reaches the kernel's case tables through `text-transform`'s link (capability `text_transform`), bounded by `MAX_STRING`."
    },
    {
      "name": "concat",
      "params": ["any", "any"],
      "returns": "any",
      "_comment": "@ref LLP 1088 §9.1: JavaScript's `Array.prototype.concat(other)` of two lists of one item type, `list<T>, list<T> -> list<T>` (the type checker's): one list step per item of the result, taken before it is built, then its extent checked as a `List` is (LLP 1090 D3)."
    },
    {
      "name": "indexOf",
      "params": ["any", "any"],
      "returns": "number",
      "_comment": "@ref LLP 1088 §9.1 (2026-10-04 note): JavaScript's `String.prototype.indexOf(needle)` — the first match's position in UTF-16 code units, `-1` for none, 0 for the empty needle — or, over a list of strings, numbers or bools, `Array.prototype.indexOf(item)` by IsStrictlyEqual (NaN is never found, -0 is 0), one list step per item scanned up to the match. `any` is the type checker's. The web's optional position argument is not taken."
    },
    {
      "name": "split",
      "params": ["string", "string"],
      "returns": "list<string>",
      "_comment": "@ref LLP 1088 §9.1 (2026-10-04 note): JavaScript's `String.prototype.split(separator)` with a string separator: the pieces between its matches, left to right; an empty separator splits into UTF-16 code units (each piece made well formed: a lone half is U+FFFD), and `\"\"` into no pieces. One list step per piece, taken before the list is built, then its extent checked as a `List` is (LLP 1090 D3). The web's limit argument and regular expressions are not taken."
    },
    {
      "name": "elementFromPoint",
      "params": ["number", "number"],
      "returns": "option<string>",
      "_comment": "@ref LLP 1094 D10: DOM's `document.elementFromPoint(x, y)?.closest(\"[id]\")?.id` over `frame`'s boxes: the `id` of the front-most laid-out box at the viewport point (every scroll and transform applied; ancestors' overflow clips; `pointer-events: none`, `display: none` and `visibility: hidden` skipped; LLP 1083.000's paint order), or of its nearest ancestor with one; `none` where no box or ancestor has one. Actions only."
    },
    {
      "name": "elementsFromPoint",
      "params": ["number", "number"],
      "returns": "list<string>",
      "_comment": "@ref LLP 1094 D10 (2026-10-11): action-only point read; own nonempty ids of every hit node, including hit ancestors, front to back, with elementFromPoint's skips and transforms."
    },
    {
      "name": "querySelectorAll",
      "params": ["string"],
      "returns": "list<string>",
      "_comment": "@ref LLP 1075.003 §9.1 (2026-10-11): action-only structural read. Only [data-<declared word>~=\"value\"] is accepted; own ids of mounted, displayed, non-inert matches in tree order."
    },
    {
      "name": "parseNumber",
      "params": ["string"],
      "returns": "option<number>",
      "_comment": "@ref LLP 1102 §3.1: a decimal number in text, `some(n)`, else `none`. Surrounding whitespace is `trim`'s; then an optional sign, digits with an optional fraction or a fraction alone (`.5`; `5.` is 5), and an optional decimal exponent (`1e3`); nothing else (`\"\"`, hex, `Infinity`, `NaN`, `12px` are `none`). The value is the correctly rounded double, as `Number()` reads it; a result past the largest finite is `none`, as is a nonzero numeral that rounds to zero; `-0` is -0."
    },
    {
      "name": "ceil",
      "params": ["number"],
      "returns": "number",
      "_comment": "@ref LLP 1102 §3.2: JavaScript's `Math.ceil`, IEEE's ceiling (`ceil(-0.5)` is -0; NaN and the infinities are their own)."
    },
    {
      "name": "round",
      "params": ["number"],
      "returns": "number",
      "_comment": "@ref LLP 1102 §3.2: JavaScript's `Math.round`: the nearest integer, a tie toward +∞ (`round(-1.5)` is -1, `round(2.5)` is 3), and -0 for a negative input that rounds to zero (`round(-0.4)` is -0); NaN and the infinities are their own. Not Rust's `f64::round`, which breaks a tie away from zero."
    },
    {
      "name": "calendarDiff",
      "params": ["string", "string", "\"years\" | \"months\""],
      "returns": "option<number>",
      "_comment": "@ref LLP 1102 §0, §3.4: the whole calendar years or months from the first ISO date (`YYYY-MM-DD`, proleptic Gregorian, years 0 through 9999) to the second, counted as an age is: a period completes when the later date's month and day reach the earlier date's (years compare month then day, months compare the day), so a Feb 29 start completes a year on Mar 1 of a common year and a Jan 31 start completes a month on Mar 1, as the web's `Temporal.PlainDate.prototype.until` counts with `largestUnit` `\"years\"` or `\"months\"` (date-fns' `differenceInMonths` differs: it lets a month's last day complete a month). When the second date is earlier, the count from it to the first, negated. `none` when either is not a valid `YYYY-MM-DD` date."
    },
    {
      "name": "toFixed",
      "params": ["number", "0..=100"],
      "returns": "string",
      "_comment": "@ref LLP 1102 §0, §3.2 (decided (c)): JavaScript's `Number.prototype.toFixed(digits)`, the binary value rounded (`toFixed(1.005, 2)` is `\"1.00\"`, a tie away from zero on the exact value), `-0.001` at 2 is `\"-0.00\"`, a magnitude of `1e21` or more printed as `toString` prints it. One declared difference: a non-finite number prints `\"\"` (LLP 1054.000.003 D7), where JavaScript prints `NaN` or `Infinity`. `digits` is a whole-number literal from 0 to 100, JavaScript's range. A linked `format` entry."
    },
    {
      "name": "formatDecimal",
      "params": ["number", "0..=20"],
      "returns": "string",
      "_comment": "@ref LLP 1102 §0, §3.2 (decided (c)): an integer count of a smallest unit as a decimal with `digits` places, exactly (`formatDecimal(1234, 2)` is `\"12.34\"`, `formatDecimal(-5, 2)` is `\"-0.05\"`, `formatDecimal(7, 0)` is `\"7\"`); `-0` prints as `0`. A count that is not an integer, or not finite, prints `\"\"`: money is a count of cents, or `formatDecimal(round(price * 100), 2)` for a price of at most two decimals under a trillion. `digits` is a whole-number literal from 0 to 20. A linked `format` entry."
    },
    {
      "name": "formatDay",
      "params": ["number", "number", "number", "\"day\" | \"day-time\" | \"list\""],
      "returns": "string",
      "_comment": "@ref LLP 1116.020 D8: a day's label for (thenMs, nowMs, utcOffset), en-US. The days are the offset's calendar days, as `formatDate`'s are (one fixed offset for both instants: a DST change between them is not applied). `day` is `Today`, `Yesterday` or `Tomorrow`, else `formatDate`'s `medium`; `day-time` adds ` at ` and `formatTime`'s `short` (`Today at 4:42 PM`, `Oct 11, 2026 at 4:42 PM`); `list` is Mail's and Notes' list label: `formatTime`'s `short` today, `Yesterday`, the weekday's name two to six days back, else the numeric short date of Intl.DateTimeFormat(\"en-US\", { dateStyle: \"short\" }) (`10/11/26`), a later day's included. `\"\"` when either instant is invalid as `formatDate` judges one (LLP 1054.000.003 D7). Pure: the app passes its own `now`. The linked capability `format`."
    },
    {
      "name": "sin",
      "params": ["number"],
      "returns": "number",
      "_comment": "@ref LLP 1017.003 §Refused (2026-10-17): JavaScript's `Math.sin` and CSS's `sin()`, of radians. The native runners compute it with `libm` (`exact_motion::math`), the same bits on every target; the web's JS target is `Math.sin`, which ECMA-262 lets differ in the last bits. NaN and the infinities are NaN."
    },
    {
      "name": "cos",
      "params": ["number"],
      "returns": "number",
      "_comment": "@ref LLP 1017.003 §Refused (2026-10-17): JavaScript's `Math.cos` and CSS's `cos()`, of radians, computed as `sin` is."
    },
    {
      "name": "sum",
      "params": ["list<number>"],
      "returns": "number",
      "_comment": "@ref LLP 1017.003 §Refused (2026-10-17): a list of numbers added left to right from +0, exactly `xs.reduce((a, x) => a + x, 0)`: `[]` is 0, `[-0]` is +0, a NaN or opposite infinities make NaN. A step an item on the evaluation's list budget, as `includes` takes (LLP 1088 §9.1). Not `Math.sumPrecise`, which rounds once."
    },
    {
      "name": "sortBy",
      "params": ["any", "any", "bool"],
      "returns": "any",
      "_comment": "@ref LLP 1116.016 §5 (Charlie, 2026-10-17): `sortBy(list<T>, (T, number) => K, \"asc\" | \"desc\"?) -> list<T>` with `K` a number or a string (the type checker's). Lowered as the list bound once as a local, a `Map` of the key callback over it (one list step an item, the key evaluated once an item), then this call on (the list, its keys, descending): the items in a stable order of their keys, a bottom-up merge sort written out alike in the runner and the JS target. Numbers by `<` with NaN as +0 (so -0, +0 and NaN tie); strings by UTF-16 code units, as `<`; equal keys keep their input order in both directions. The call takes no list step: its n·⌈log₂ n⌉ comparisons are the stated cost (LLP 1116.016 D0); the list it builds is measured as `List` measures one."
    },
    {
      "name": "toUpperCase",
      "params": ["string"],
      "returns": "string",
      "_comment": "@ref LLP 1088 D2 (admitted 2026-10-17): JavaScript's `String.prototype.toUpperCase()`: Unicode's default, locale-independent full mapping, expansions included (`ß` is `SS`). Linked by use through the same case tables as `toLowerCase` (capability `text_transform`), bounded by `MAX_STRING`. Displayed text is uppercased by `text-transform`, not by this."
    },
    {
      "name": "range",
      "params": ["number"],
      "returns": "list<number>",
      "_comment": "@ref LLP 1017.003 §Refused (admitted 2026-10-17): Exact's own, not the web's: the whole numbers 0 to n - 1 in order, `[]` for 0. `n` is a whole number at least 0 (`-0` is 0); any other, NaN and the infinities included, is a `TypeMismatch` trap, as the arguments do not fit (the compiler refuses such a literal). One list step an item, taken before the list is built (as `concat`), so an `n` past the bound traps `IterationLimit`; the list's extent is checked as a `List` is."
    },
    {
      "name": "flat",
      "params": ["any"],
      "returns": "any",
      "_comment": "@ref LLP 1017.003 §Refused (admitted 2026-10-17): JavaScript's `Array.prototype.flat()` at its default depth, 1: a list of lists' items in order, `list<list<T>> -> list<T>` (the type checker's; no depth is taken). One list step an outer item and one an item it emits, taken before the list is built, as `concat` takes them; the result's extent is checked as a `List` is."
    },
    {
      "name": "rangeFrame",
      "params": ["string", "number", "number"],
      "returns": "Geometry",
      "_comment": "@ref LLP 1114.007: `Range.getBoundingClientRect()` of a text field's UTF-16 range, read in an action from the field's last presented layout: offsets truncated toward zero; a collapsed range the caret's rectangle, a wider one the union of its line fragments, untrimmed by scrolling or the field's clip. Unavailable for a non-finite or negative offset, a start past the end, an end past the text, a missing or hidden field, active composition, or a host with no reader."
    },
    {
      "name": "sharedFiles",
      "params": ["Entry", "string"],
      "returns": "SharedFiles",
      "_comment": "@ref LLP 1133.024 D3: the files a received share carried, by the token in the entry's `name` parameter: `{files: Picked[], dropped, pending}`, `pending` those still being copied. A token the host did not set this launch answers no files. The host sets the token by `set_shared`, so a read is not a pure function of its arguments: the runner re-evaluates its readers at every update."
    },
    {
      "name": "fragment",
      "params": ["Entry"],
      "returns": "string",
      "_comment": "@ref LLP 1153 D5: the entry's fragment, what its location had after `#` with the fragment percent-encode set applied, `\"\"` when none. It is no part of the screen's identity; a host scrolls to the element it names once the route's content has arrived."
    }
  ],
  "_sources": "LLP 1027 D2: the data seam's signatures. One row per data-source name the app's `resource` and `send` declarations use, with the parameter types and the result type every use agrees on (the compiler refuses a disagreement by name). An executor that marshals by shape \u2014 the TypeScript module's \u2014 reads this table at bind; a Rust crate ignores it. formatVersion 3.",
  "_resources": "`reader` (formatVersion 4, LLP 1027 D4 as ruled 2026-09-03): the bake found this resource consulting the store. Its `initial` is then the empty-store answer \u2014 the fresh install's first frame, never a developer's session (the bake's store is empty by construction, LLP 1018 D4) \u2014 and the runner treats it as a placeholder: a kept answer from the device's store beats it, and a data source that is not ready at boot (a TypeScript module before its host loads it) is asked again at `data_ready`. LLP 1038 D5: initial_args is a canonical Value::List of evaluated bake arguments, empty bytes only without a compiled value; initial is reused only for equal arguments. LLP 1027.005 D6: context is the trailing request-context count (0 without `with`), bounded by args.len. The persisted kept entry stores only the identifying prefix; only its admission while the source is unready compares that prefix. Every live request, compiled value, carry and document checkpoint still compares the full arguments."
}