@tabnas/proto 0.6.5 → 0.6.7

package/dist/translate.js

@@ -0,0 +1,1043 @@
+"use strict";
+/* Copyright (c) 2026 Richard Rodger and other contributors, MIT License */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translate = translate;
+const TRANSLATION = Object.freeze({
+    manifest: `{
+  "$schema": "https://tabnas.dev/schema/plugin.schema.json",
+  "name": "@tabnas/proto",
+  "go": "github.com/tabnas/proto/go",
+  "rust": "tabnas-proto",
+  "description": "Protocol Buffers IDL parsing for the tabnas engine (proto2, proto3, editions).",
+  "engine": "@tabnas/parser",
+  "extensions": [
+    ".proto"
+  ],
+  "languageId": "proto",
+  "specDir": "test/spec",
+  "clib": {
+    "dir": "go/clib",
+    "library": "libtabnasproto",
+    "abi": "v1",
+    "errorCodes": [
+      "usage",
+      "grammar",
+      "handle",
+      "internal"
+    ]
+  },
+  "errorCodes": [],
+  "docs": "https://tabnas.dev/docs/packages",
+  "repository": "https://github.com/tabnas/proto",
+  "versionSource": "ts/package.json",
+  "translate": {
+    "reads": "tree",
+    "writes": "tree",
+    "root": "object",
+    "schema": "proto-descriptor",
+    "render": "alchemy/render.alc",
+    "loss": [
+      "The file is written anew from its descriptor: comments, blank lines and white space are not kept, and each statement is written on lines of its own, indented two spaces a level.",
+      "Statements are written in the order the descriptor's lists keep them, so statements of different kinds that the file interleaved are regrouped: the syntax or edition first, then the package, the imports and the file's options, then the messages, the enums, the services and the extensions, and in a message its options, its fields with each nested message where it keeps its place among them, its enums, its extensions and its ranges.",
+      "A file that declares no syntax is written with syntax = \\"proto2\\", the version the reader gives it, and a descriptor's name, which the reader never sets, is not written.",
+      "A label the descriptor does not keep is not written as the file spelled it: an optional field of a proto2 file is written optional whether or not the file said so, and an optional field of a proto3 file that the descriptor does not mark proto3Optional, or of an edition file, is written with no label.",
+      "A map field is written as map<K, V> from the entry message the reader made for it, a group as a group block from its nested message, and a proto3 optional field's synthetic oneof is not written, since the reader makes each of them again.",
+      "A number is written as the descriptor holds it: a hexadecimal or octal field number, enum value or range bound is written in decimal, an exclusive range end as its last number or max, and a number the reader read as NaN (a digit separator, 1_0, which the lexer takes and JavaScript's Number refuses) as 0_0, which reads back as NaN.",
+      "A string literal is written between double quotes, or single quotes where its text holds a double quote and no single quote, its escapes as written, since the descriptor keeps a literal's text between its quotes; a text that holds both quotes is written between double quotes, and reads back as written only where each double quote in it is escaped.",
+      "An option's value is one string to the descriptor whether the file wrote it as an identifier, a string literal or an aggregate in braces, so it is written as a string literal, as an aggregate only where no literal can hold its text (a line break, or both quotes), and as an identifier for the options descriptor.proto types as enums (optimize_for, ctype, jstype, retention, targets, idempotency_level and the features) when its text is made of identifier characters; protoc reads an enum-valued or message-valued option written as a literal as a string, and a quoted value of such an option that begins with a digit, which protoc refuses, does not read back.",
+      "A default is written bare for a field that is not a string or bytes when its text is made of a constant's characters, and as a string literal otherwise; a quoted default of such a field whose text is made of those characters but spells no one constant, which protoc refuses, does not read back.",
+      "Reserved names are written as string literals in a proto2 or proto3 file and as identifiers in an edition file, a message's or an enum's reserved ranges in one reserved statement and its names in another, each extension range in an extensions statement of its own with its options, and each extension in an extend block of its own."
+    ]
+  }
+}
+`,
+    render: Object.freeze({ entry: "proto-render", source: `; Protocol Buffers' render: the reader's tree, a FileDescriptorProto, written
+; back as one \`.proto\` file. This is a library of definitions, each named
+; \`proto-...\`, which a host links with its own program (alchemy's
+; \`compile_sources\`); its entry point is \`proto-render\`, and nothing else
+; here is the host's to call.
+;
+; The render writes the reader's own tree and no other, as the
+; translation design says a render of a format whose value has a shape of
+; its own does: the manifest names that shape as the schema
+; \`proto-descriptor\`, and a host composes into this render only from a
+; source of the same schema or from a program that builds the tree. The
+; contract is the round trip: the text it writes reads back, through this
+; repository's reader, as the tree it was given. The tree keeps what a
+; descriptor holds and not how the file spelled it, so the render chooses
+; a spelling for each part, the one that reads back the same, as the
+; manifest's loss list says:
+;
+; - The file is the \`syntax\` or \`edition\` declaration, then the package,
+;   the imports (\`public\`, \`weak\`, and edition 2024's \`import option\`) and
+;   the file's options, in the order the tree holds them, then the
+;   messages, the enums, the services and the extensions, each a statement
+;   or a block on lines of its own, indented two spaces a level.
+; - A message's body is its options, then its fields in order, each nested
+;   message written where it keeps its place among the fields' own (a map
+;   field's entry and a group's message are nested types too, written as
+;   the map field and the group), the declared oneofs as blocks around
+;   their fields (a proto3 \`optional\` field's synthetic oneof is not one:
+;   the field is written \`optional\`), then its enums, its extensions (an
+;   \`extend\` block each), its extension ranges and its reserved ranges and
+;   names, in the order the tree holds them. A map field's entry is a
+;   nested type the reader would make for the field again: named for it
+;   by protoc's rule and like the reader's entry in every member. Any
+;   other, a message the file declared with the option \`mapEntry\` among
+;   them, is written as a message, and the field as a field of its type.
+; - A field is its label (none in a oneof; \`optional\` for a proto2 field
+;   the tree marks optional, and for a proto3 field the tree marks
+;   \`proto3Optional\`; nothing for the other optional fields), its type (a
+;   scalar's keyword, or the type name as written), its name, its number
+;   and its options in brackets: \`default\`, \`json_name\` and the rest.
+; - An exclusive range end (a message's reserved and extension ranges) is
+;   written one below the tree's, or \`max\` where it is the bound \`to max\`
+;   gives (536870912, or 2147483647 under \`message_set_wire_format\`); an
+;   enum's inclusive end as it is, \`max\` for 2147483647.
+; - A string from a string literal is kept as its text between the quotes,
+;   escapes as written, so it is written between double quotes, or single
+;   quotes where it holds a double quote and no single quote. An option's
+;   value the reader read as an identifier, a quoted literal or an
+;   aggregate in braces is one string to the tree: it is written quoted,
+;   as an aggregate (\`{...}\`) where no literal can hold it (a line break, or
+;   both quotes), and as an identifier for the options descriptor.proto
+;   types as enums (\`optimize_for\`, \`ctype\`, \`jstype\`, \`retention\`,
+;   \`targets\`, \`idempotency_level\` and the features) where it is made of
+;   identifier characters. A default is written bare for a field that is
+;   not a string or bytes, where it is made of the characters a constant
+;   is, and as a literal otherwise. alchemy cannot read a string a
+;   character at a time, so three texts a file can hold, each refused by
+;   protoc but one, do not read back: a literal's text holding both
+;   quotes with a double quote unescaped, a quoted value of an enum-typed
+;   option that begins with a digit, and a quoted default of a field that
+;   is not a string whose text is a constant's characters spelling no one
+;   constant.
+; - A field or enum number the reader could not read (JavaScript's Number
+;   of \`1_0\`, the lexer's digit separator) is NaN, null in JSON, and is
+;   written \`0_0\`, which reads back the same; an option's number that is
+;   null in JSON is infinite, and is written \`1e999\`.
+;
+; Anything else fails with TARGET_VALUE_UNREPRESENTABLE, naming what was
+; met: a root that is not an object, a syntax or an edition a \`.proto\`
+; file cannot declare, a member a descriptor holds as a string that is not
+; one, a field type that is no scalar's, an option's value that is not a
+; string, a number or a boolean.
+;
+; The tree is materialized whole before a line is written, since the
+; syntax comes first in the file and last in the tree, and a field's place
+; depends on the nested types after it. A pass over the events before
+; that gives every object's string \`name\` a member \`$name\` holding it as
+; a key, the one way alchemy compares two strings it did not write: a
+; field's type name is looked up in a nested type's \`$name\`. Nothing of
+; that member is written.
+
+; ---- the annotation
+
+; Each object's \`name\`, when it is a string, gets a member \`$name\` right
+; after it: an object whose one key is the name. The state is whether the
+; last event was the key \`name\`.
+def proto-mark-step [s event]
+  match event
+    case (key name)
+      match name
+        case "name" (transition :name [event])
+        case _ (transition :other [event])
+    case (scalar value)
+      match s
+        case :name
+          match (kind value)
+            case :string (transition :other [event (key "$name") object-start (key value) (scalar true) object-end])
+            case _ (transition :other [event])
+        case _ (transition :other [event])
+    case _ (transition :other [event])
+
+def proto-mark-finish [s] []
+
+; Whether the string s is the name of the object o.
+def proto-named [s o]
+  match (kind (get "$name" o))
+    case :record
+      match (kind (get-path (as-path [s]) (get "$name" o)))
+        case :missing false
+        case _ true
+    case _ false
+
+; ---- members
+
+def proto-has [k o]
+  match (kind (get k o))
+    case :missing false
+    case _ true
+
+def proto-list [k o]
+  match (kind (get k o))
+    case :vector (as-vector (get k o))
+    case _ []
+
+def proto-record [k o]
+  match (kind (get k o))
+    case :record (get k o)
+    case _ (record)
+
+def proto-at [v i]
+  get-path (as-path [i]) v
+
+; A member the tree holds as a string, or a failure naming it.
+def proto-text [what k o]
+  match (kind (get k o))
+    case :string (get k o)
+    case _ (fail :unrepresentable (string-join "" ["the tree is not a FileDescriptorProto: " what " has no string " k]))
+
+def proto-name [what o]
+  proto-text what "name" o
+
+def proto-nonempty [s]
+  match s
+    case "" false
+    case _ true
+
+def proto-real-key [k]
+  match k
+    case "$name" false
+    case _ true
+
+def proto-less [a b]
+  match (compare a b)
+    case :less true
+    case _ false
+
+def proto-same-number [a b]
+  match (compare a b)
+    case :equal true
+    case _ false
+
+def proto-member [i v]
+  match (count (filter (fn [x] (proto-same-number x i)) v))
+    case 0 false
+    case _ true
+
+def proto-lines [items]
+  string-join "\\n" (filter proto-nonempty items)
+
+def proto-deeper [indent]
+  string-join "" [indent "  "]
+
+; A block: its head, then its body on the lines below it, or \`{}\` when the
+; body is empty.
+def proto-block [indent head body]
+  match body
+    case "" (string-join "" [indent head " {}"])
+    case _ (string-join "" [indent head " {\\n" body "\\n" indent "}"])
+
+; ---- scalars
+
+; A number: its lexeme, or as the JSON renderer writes it; NaN, null in
+; JSON, as \`0_0\`, which the reader reads as NaN again.
+def proto-num [n]
+  match (kind n)
+    case :number
+      match (number-class n)
+        case :finite (scalar-text csv-options n)
+        case :infinity "1e999"
+        case :negative-infinity "-1e999"
+        case :nan "0_0"
+    case :null "0_0"
+    case _ (fail :unrepresentable "the tree is not a FileDescriptorProto: a number is not one")
+
+; The characters a literal holds as they are between double quotes, and
+; between single quotes: none of the controls, and not that quote.
+def proto-no-dq [[32 33] [35 1114111]]
+
+def proto-no-sq [[32 38] [40 1114111]]
+
+def proto-ident-chars [[48 57] [65 90] [95 95] [97 122]]
+
+; The characters of a bare constant: a number, a signed one, an identifier.
+def proto-bare-chars [[43 43] [45 46] [48 57] [65 90] [95 95] [97 122]]
+
+; A string literal whose text between its quotes is s, as written.
+def proto-literal [s]
+  match (chars-within proto-no-dq s)
+    case true (string-join "" ["\\"" s "\\""])
+    case false
+      match (chars-within proto-no-sq s)
+        case true (string-join "" ["'" s "'"])
+        case false (string-join "" ["\\"" s "\\""])
+
+; An option's string: a literal, or an aggregate where no literal holds it.
+def proto-option-string [s]
+  match (chars-within proto-no-dq s)
+    case true (string-join "" ["\\"" s "\\""])
+    case false
+      match (chars-within proto-no-sq s)
+        case true (string-join "" ["'" s "'"])
+        case false (string-join "" ["{" s "}"])
+
+; The options descriptor.proto types as enums, whose values are identifiers.
+def proto-enum-option [k]
+  match k
+    case "optimize_for" true
+    case "ctype" true
+    case "jstype" true
+    case "retention" true
+    case "targets" true
+    case "idempotency_level" true
+    case "features.field_presence" true
+    case "features.enum_type" true
+    case "features.repeated_field_encoding" true
+    case "features.utf8_validation" true
+    case "features.message_encoding" true
+    case "features.json_format" true
+    case "features.enforce_naming_style" true
+    case "features.default_symbol_visibility" true
+    case "features.(pb.cpp).string_type" true
+    case "features.(pb.java).utf8_validation" true
+    case "features.(pb.java).nest_in_file_class" true
+    case "features.(pb.go).api_level" true
+    case "features.(pb.go).strip_enum_prefix" true
+    case _ false
+
+def proto-identifier [s]
+  match s
+    case "" false
+    case "true" false
+    case "false" false
+    case _ (chars-within proto-ident-chars s)
+
+def proto-value [k v]
+  match (kind v)
+    case :boolean
+      match v
+        case true "true"
+        case false "false"
+    case :number (proto-num v)
+    case :null "1e999"
+    case :string
+      match (proto-enum-option k)
+        case true
+          match (proto-identifier v)
+            case true v
+            case false (proto-option-string v)
+        case false (proto-option-string v)
+    case _ (fail :unrepresentable "the tree is not a FileDescriptorProto: an option's value is not a string, a number or a boolean")
+
+; ---- options
+
+def proto-option-lines [indent opts]
+  string-join "\\n"
+    map
+      fn [k]
+        string-join "" [indent "option " k " = " (proto-value k (get k opts)) ";"]
+      filter proto-real-key (keys opts)
+
+def proto-option-items [opts]
+  string-join ", "
+    map
+      fn [k]
+        string-join "" [k " = " (proto-value k (get k opts))]
+      filter proto-real-key (keys opts)
+
+def proto-brackets [items]
+  match items
+    case "" ""
+    case _ (string-join "" [" [" items "]"])
+
+def proto-plain-options [o]
+  proto-brackets (proto-option-items (proto-record "options" o))
+
+; ---- fields
+
+def proto-default [f]
+  let [v (proto-text "a field's default" "defaultValue" f)]
+    match (get "type" f)
+      case "TYPE_STRING" (proto-literal v)
+      case "TYPE_BYTES" (proto-literal v)
+      case _
+        match v
+          case "" (proto-literal v)
+          case _
+            match (chars-within proto-bare-chars v)
+              case true v
+              case false (proto-literal v)
+
+def proto-field-options [f]
+  proto-brackets
+    string-join ", "
+      filter proto-nonempty
+        vector
+          match (proto-has "defaultValue" f)
+            case true (string-join "" ["default = " (proto-default f)])
+            case false ""
+          match (proto-has "jsonName" f)
+            case true (string-join "" ["json_name = " (proto-literal (proto-text "a field" "jsonName" f))])
+            case false ""
+          proto-option-items (proto-record "options" f)
+
+def proto-scalar-type [t]
+  match t
+    case "TYPE_DOUBLE" "double"
+    case "TYPE_FLOAT" "float"
+    case "TYPE_INT64" "int64"
+    case "TYPE_UINT64" "uint64"
+    case "TYPE_INT32" "int32"
+    case "TYPE_FIXED64" "fixed64"
+    case "TYPE_FIXED32" "fixed32"
+    case "TYPE_BOOL" "bool"
+    case "TYPE_STRING" "string"
+    case "TYPE_BYTES" "bytes"
+    case "TYPE_UINT32" "uint32"
+    case "TYPE_SFIXED32" "sfixed32"
+    case "TYPE_SFIXED64" "sfixed64"
+    case "TYPE_SINT32" "sint32"
+    case "TYPE_SINT64" "sint64"
+    case _ (fail :unrepresentable "the tree is not a FileDescriptorProto: a field's type is no scalar a .proto file names")
+
+def proto-type [f]
+  match (proto-has "type" f)
+    case true (proto-scalar-type (get "type" f))
+    case false (proto-text "a field" "typeName" f)
+
+def proto-label [syntax f]
+  match (get "label" f)
+    case "LABEL_REQUIRED" "required "
+    case "LABEL_REPEATED" "repeated "
+    case _
+      match (get "proto3Optional" f)
+        case true "optional "
+        case _
+          match syntax
+            case "proto2" "optional "
+            case _ ""
+
+def proto-field-line [syntax indent f labelled]
+  string-join ""
+    vector
+      indent
+      match labelled
+        case true (proto-label syntax f)
+        case false ""
+      proto-type f
+      " "
+      proto-name "a field" f
+      " = "
+      proto-num (get "number" f)
+      proto-field-options f
+      ";"
+
+def proto-visibility [o]
+  match (get "visibility" o)
+    case "VISIBILITY_EXPORT" "export "
+    case "VISIBILITY_LOCAL" "local "
+    case _ ""
+
+; ---- ranges
+
+; The decimal digits, and the places of a number's text.
+def proto-digits-down ["9" "8" "7" "6" "5" "4" "3" "2" "1"]
+
+def proto-digits-up ["0" "1" "2" "3" "4" "5" "6" "7" "8" "9"]
+
+def proto-places [0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]
+
+def proto-places-of [text]
+  filter (fn [i] (proto-less i (length text))) proto-places
+
+; A digit after a prefix, a leading zero dropped.
+def proto-append-digit [prefix d]
+  match [prefix d]
+    case ["" "0"] ""
+    case _ (string-join "" [prefix d])
+
+; The decimal text of n - 1 for an integer n of at least 1, a digit a
+; place from the left: at each place, the largest digit after which some
+; number is still below n, which is the one whose zeros after it are.
+; alchemy has no arithmetic, so the predecessor is found by comparison.
+def proto-pred-pos [self places prefix n]
+  match (count places)
+    case 0
+      match prefix
+        case "" "0"
+        case _ prefix
+    case _
+      let [zeros (repeat (count (pop places)) "0")]
+        let [found (filter (fn [d] (proto-less (number (string-join "" [prefix d zeros])) n)) proto-digits-down)]
+          match (count found)
+            case 0 (self self (pop places) (proto-append-digit prefix "0") n)
+            case _ (self self (pop places) (proto-append-digit prefix (proto-at found 0)) n)
+
+def proto-below-negated [prefix d nines n]
+  let [digits (string-join "" [(proto-append-digit prefix d) nines])]
+    match digits
+      case "" false
+      case _ (proto-less (number (string-join "" ["-" digits])) n)
+
+; The same for a negative n: the smallest m with -m below n, a digit a
+; place from the left, the smallest digit after which nines still are.
+def proto-pred-neg [self places prefix n]
+  match (count places)
+    case 0 (string-join "" ["-" prefix])
+    case _
+      let [nines (repeat (count (pop places)) "9")]
+        let [found (filter (fn [d] (proto-below-negated prefix d nines n)) proto-digits-up)]
+          self self (pop places) (proto-append-digit prefix (proto-at found 0)) n
+
+def proto-pred [n]
+  match (compare n 0)
+    case :greater (proto-pred-pos proto-pred-pos (proto-places-of (proto-num n)) "" n)
+    case :equal "-1"
+    case _ (proto-pred-neg proto-pred-neg (proto-places-of (proto-num n)) "" n)
+
+; A message's range, whose end is exclusive: \`start\`, \`start to last\` or
+; \`start to max\`.
+def proto-range-ex [maxv r]
+  let [s (get "start" r)]
+    let [e (get "end" r)]
+      match (compare e maxv)
+        case :equal (string-join "" [(proto-num s) " to max"])
+        case _
+          let [p (proto-pred e)]
+            match (compare (number p) s)
+              case :equal (proto-num s)
+              case _ (string-join "" [(proto-num s) " to " p])
+
+; An enum's reserved range, whose end is inclusive.
+def proto-range-in [r]
+  let [s (get "start" r)]
+    let [e (get "end" r)]
+      match (compare e s)
+        case :equal (proto-num s)
+        case _
+          match (compare e 2147483647)
+            case :equal (string-join "" [(proto-num s) " to max"])
+            case _ (string-join "" [(proto-num s) " to " (proto-num e)])
+
+; The end \`to max\` gives in a message.
+def proto-max [m]
+  match (get "message_set_wire_format" (proto-record "options" m))
+    case true 2147483647
+    case _ 536870912
+
+; A reserved name: an identifier in an editions file, a literal before.
+def proto-reserved-name [syntax n]
+  match syntax
+    case "editions"
+      match (proto-identifier n)
+        case true n
+        case false (proto-literal n)
+    case _ (proto-literal n)
+
+def proto-reserved-names [syntax indent names]
+  match (count names)
+    case 0 ""
+    case _ (string-join "" [indent "reserved " (string-join ", " (map (fn [n] (proto-reserved-name syntax n)) names)) ";"])
+
+def proto-reserved-ranges [indent text]
+  match text
+    case "" ""
+    case _ (string-join "" [indent "reserved " text ";"])
+
+; ---- messages
+
+; Whether two strings are the same. alchemy matches a string against a
+; literal and against no other string, but \`split\` cuts a string at every
+; occurrence of a separator that is not empty, so a string cut by itself,
+; and by nothing else, is two empty strings.
+def proto-same-text [a b]
+  match a
+    case ""
+      match b
+        case "" true
+        case _ false
+    case _
+      match (split a b)
+        case ["" ""] true
+        case _ false
+
+; Whether v is a string and the string s.
+def proto-is-text [s v]
+  match (kind v)
+    case :string (proto-same-text s v)
+    case _ false
+
+; Whether the string p begins with the string c, which is not empty, and p
+; without that first c.
+def proto-begins [c p]
+  let [parts (split c p)]
+    match (proto-at parts 0)
+      case "" (proto-less 1 (count parts))
+      case _ false
+
+def proto-after [c p]
+  let [parts (split c p)]
+    string-join c (map (fn [i] (proto-at parts i)) (filter (fn [i] (proto-less 0 i)) (indices parts)))
+
+; The letters protoc puts in upper case in an entry's name.
+def proto-letters [["a" "A"] ["b" "B"] ["c" "C"] ["d" "D"] ["e" "E"] ["f" "F"] ["g" "G"] ["h" "H"] ["i" "I"] ["j" "J"] ["k" "K"] ["l" "L"] ["m" "M"] ["n" "N"] ["o" "O"] ["p" "P"] ["q" "Q"] ["r" "R"] ["s" "S"] ["t" "T"] ["u" "U"] ["v" "V"] ["w" "W"] ["x" "X"] ["y" "Y"] ["z" "Z"]]
+
+; A part of a name, its first letter in upper case where it is one from a
+; to z.
+def proto-capital [p]
+  let [hits (filter (fn [l] (proto-begins (proto-at l 0) p)) proto-letters)]
+    match (count hits)
+      case 0 p
+      case _ (string-join "" [(proto-at (proto-at hits 0) 1) (proto-after (proto-at (proto-at hits 0) 0) p)])
+
+; The name protoc gives a map field's entry, which the reader gives the
+; entry it makes: the field's name with each \`_\` dropped and the letter
+; after it, and the first, in upper case, then \`Entry\` (\`map_field\` is
+; \`MapFieldEntry\`).
+def proto-entry-name [name]
+  string-join "" [(string-join "" (map proto-capital (split "_" name))) "Entry"]
+
+; Whether every key of the object o is one of the keys allowed.
+def proto-only [allowed o]
+  match (count (filter (fn [k] (proto-less (count (filter (fn [a] (proto-same-text a k)) allowed)) 1)) (keys o)))
+    case 0 true
+    case _ false
+
+def proto-empty [k o]
+  match (kind (get k o))
+    case :vector
+      match (count (as-vector (get k o)))
+        case 0 true
+        case _ false
+    case _ false
+
+; The options the reader copies from a map field to its entry's key and
+; value: \`features\`, and those whose name begins \`features.\`.
+def proto-feature-key [k]
+  match k
+    case "features" true
+    case _ (proto-begins "features." k)
+
+; Whether two options' values are the same: of one kind, and alike.
+def proto-same-value [a b]
+  match [(kind a) (kind b)]
+    case [:string :string] (proto-same-text a b)
+    case [:number :number] (proto-same-number a b)
+    case [:boolean :boolean]
+      match [a b]
+        case [true true] true
+        case [false false] true
+        case _ false
+    case [:record :record] (proto-same-text (scalar-text csv-options a) (scalar-text csv-options b))
+    case _ false
+
+; Whether a field of an entry has the options the reader gives it: the
+; features of the map field fo, by name, \`feats\`, and none where it has
+; none.
+def proto-entry-options [fo feats g]
+  match [(count feats) (proto-has "options" g)]
+    case [0 false] true
+    case [0 true] false
+    case [_ false] false
+    case _
+      let [o (get "options" g)]
+        match (kind o)
+          case :record
+            match (proto-same-number (count (keys o)) (count feats))
+              case true (proto-same-number (count (filter (fn [k] (proto-same-value (get k o) (get k fo))) feats)) (count feats))
+              case false false
+          case _ false
+
+def proto-entry-field-keys ["name" "$name" "number" "label" "type" "typeName" "options"]
+
+; Whether g is a field of an entry as the reader makes it, \`key\` 1 or
+; \`value\` 2: optional, of a type or a type name, and with no option but
+; the features the map field passes down.
+def proto-entry-field [name number fo feats g]
+  match (kind g)
+    case :record
+      match [(proto-is-text name (get "name" g)) (get "label" g) (kind (get "number" g)) (proto-has "type" g) (proto-has "typeName" g) (proto-only proto-entry-field-keys g)]
+        case [true "LABEL_OPTIONAL" :number true false true]
+          match (proto-same-number (get "number" g) number)
+            case true (proto-entry-options fo feats g)
+            case false false
+        case [true "LABEL_OPTIONAL" :number false true true]
+          match (proto-same-number (get "number" g) number)
+            case true (proto-entry-options fo feats g)
+            case false false
+        case _ false
+    case _ false
+
+def proto-entry-keys ["name" "$name" "field" "nestedType" "enumType" "oneofDecl" "extension" "options"]
+
+; Whether the nested type n is the entry the reader makes for the map
+; field f, so that f written as a map reads back with n as it is: n named
+; for f by protoc's rule, with no member but its fields, its empty lists
+; and the option \`mapEntry\` alone, and its fields \`key\` and \`value\` as the
+; reader makes them. A message the file declares, the option \`mapEntry\`
+; in it, is any other one, and is written as a message.
+def proto-map-entry [f n]
+  match [(kind (get "name" f)) (kind (get "name" n))]
+    case [:string :string]
+      match [(proto-same-text (proto-entry-name (get "name" f)) (get "name" n)) (proto-only proto-entry-keys n)]
+        case [true true]
+          let [o (proto-record "options" n)]
+            match [(proto-empty "nestedType" n) (proto-empty "enumType" n) (proto-empty "oneofDecl" n) (proto-empty "extension" n) (count (keys o)) (get "mapEntry" o)]
+              case [true true true true 1 true]
+                let [kv (proto-list "field" n)]
+                  match (count kv)
+                    case 2
+                      let [fo (proto-record "options" f)]
+                        let [feats (filter proto-feature-key (keys fo))]
+                          match [(proto-entry-field "key" 1 fo feats (proto-at kv 0)) (proto-entry-field "value" 2 fo feats (proto-at kv 1))]
+                            case [true true] true
+                            case _ false
+                    case _ false
+              case _ false
+        case _ false
+    case _ false
+
+def proto-first [v]
+  match (count v)
+    case 0 -1
+    case _ (proto-at v 0)
+
+def proto-last [v]
+  match (count v)
+    case 0 -1
+    case _ (top v)
+
+def proto-entry-named [f n]
+  match (proto-named (get "typeName" f) n)
+    case true (proto-map-entry f n)
+    case false false
+
+; The nested type a field is written with, its index, or -1: a group's
+; message, and a map field's entry. A map field is a repeated field whose
+; type is named for a nested type that is the entry the reader would make
+; for it (\`proto-map-entry\`).
+def proto-attached [ns f]
+  match (get "type" f)
+    case "TYPE_GROUP" (proto-first (filter (fn [t] (proto-named (get "typeName" f) (proto-at ns t))) (indices ns)))
+    case _
+      match (get "label" f)
+        case "LABEL_REPEATED"
+          match [(proto-has "type" f) (proto-has "typeName" f) (proto-has "oneofIndex" f) (proto-has "extendee" f)]
+            case [false true false false] (proto-first (filter (fn [t] (proto-entry-named f (proto-at ns t))) (indices ns)))
+            case _ -1
+        case _ -1
+
+; Whether a field is in a declared oneof: a proto3 \`optional\` field's
+; oneof is synthetic, and the field is written \`optional\`.
+def proto-in-oneof [f]
+  match (proto-has "oneofIndex" f)
+    case true
+      match (get "proto3Optional" f)
+        case true false
+        case _ true
+    case false false
+
+def proto-same-oneof [fs j k]
+  let [a (proto-at fs j)]
+    let [b (proto-at fs k)]
+      match (proto-in-oneof b)
+        case true (proto-same-number (get "oneofIndex" a) (get "oneofIndex" b))
+        case false false
+
+; A unit is a field, or a declared oneof's fields, which are adjacent in
+; the tree; it is written at its first field.
+def proto-unit-start [fs j]
+  match (proto-in-oneof (proto-at fs j))
+    case false true
+    case true
+      match (count (filter (fn [k] (proto-less k j)) (filter (fn [k] (proto-same-oneof fs j k)) (indices fs))))
+        case 0 true
+        case _ false
+
+def proto-unit-fields [fs j]
+  match (proto-in-oneof (proto-at fs j))
+    case false [j]
+    case true (filter (fn [k] (proto-same-oneof fs j k)) (indices fs))
+
+def proto-attached-of [att ks]
+  filter (fn [t] (proto-less -1 t)) (map (fn [k] (proto-at att k)) ks)
+
+; The nested types written as messages, between two attached ones.
+def proto-plain-nested [ns att lo hi]
+  filter
+    fn [t]
+      match (proto-member t att)
+        case true false
+        case false
+          match [(proto-less lo t) (proto-less t hi)]
+            case [true true] true
+            case _ false
+    indices ns
+
+; The messages due before a unit: those after the nested type of the last
+; attached field before it and before the unit's own first.
+def proto-nested-before [indent ns bodies fs att j]
+  let [mine (proto-attached-of att (proto-unit-fields fs j))]
+    match (count mine)
+      case 0 ""
+      case _
+        let [lo (proto-last (proto-attached-of att (filter (fn [k] (proto-less k j)) (indices fs))))]
+          string-join "\\n"
+            map (fn [t] (proto-message indent (proto-at ns t) (proto-at bodies t))) (proto-plain-nested ns att lo (proto-at mine 0))
+
+def proto-nested-after [indent ns bodies att]
+  let [lo (proto-last (filter (fn [t] (proto-less -1 t)) att))]
+    string-join "\\n"
+      map (fn [t] (proto-message indent (proto-at ns t) (proto-at bodies t))) (proto-plain-nested ns att lo 4294967296)
+
+; The declared oneofs: all but the synthetic ones of proto3 \`optional\`.
+def proto-declared-oneofs [m]
+  let [synthetic (map (fn [f] (get "oneofIndex" f)) (filter (fn [f] (match (get "proto3Optional" f) (case true (proto-has "oneofIndex" f)) (case _ false))) (proto-list "field" m)))]
+    filter (fn [i] (match (proto-member i synthetic) (case true false) (case false true))) (indices (proto-list "oneofDecl" m))
+
+; The declared oneofs no field is in.
+def proto-empty-oneofs [m]
+  let [used (map (fn [f] (get "oneofIndex" f)) (filter proto-in-oneof (proto-list "field" m)))]
+    filter (fn [i] (match (proto-member i used) (case true false) (case false true))) (proto-declared-oneofs m)
+
+def proto-oneof-block [indent m i members]
+  let [o (proto-at (proto-list "oneofDecl" m) i)]
+    proto-block indent (string-join "" ["oneof " (proto-name "a oneof" o)])
+      proto-lines
+        vector
+          proto-option-lines (proto-deeper indent) (proto-record "options" o)
+          members
+
+; The empty oneofs due before a unit's oneof: those after the last oneof
+; written before it.
+def proto-oneofs-before [indent m fs j]
+  let [f (proto-at fs j)]
+    match (proto-in-oneof f)
+      case false ""
+      case true
+        let [lo (proto-last (map (fn [k] (get "oneofIndex" (proto-at fs k))) (filter (fn [k] (match (proto-less k j) (case true (proto-in-oneof (proto-at fs k))) (case false false))) (indices fs))))]
+          string-join "\\n"
+            map
+              fn [i]
+                proto-oneof-block indent m i ""
+              filter (fn [i] (match [(proto-less lo i) (proto-less i (get "oneofIndex" f))] (case [true true] true) (case _ false))) (proto-empty-oneofs m)
+
+def proto-oneofs-after [indent m]
+  let [lo (proto-last (map (fn [f] (get "oneofIndex" f)) (filter proto-in-oneof (proto-list "field" m))))]
+    string-join "\\n"
+      map
+        fn [i]
+          proto-oneof-block indent m i ""
+        filter (fn [i] (proto-less lo i)) (proto-empty-oneofs m)
+
+def proto-group-block [syntax indent f body labelled]
+  proto-block indent
+    string-join ""
+      vector
+        match labelled
+          case true (proto-label syntax f)
+          case false ""
+        "group "
+        proto-text "a group" "typeName" f
+        " = "
+        proto-num (get "number" f)
+    body
+
+def proto-map-line [indent f n]
+  let [kv (proto-list "field" n)]
+    string-join ""
+      vector
+        indent
+        "map<"
+        proto-type (proto-at kv 0)
+        ", "
+        proto-type (proto-at kv 1)
+        "> "
+        proto-name "a map field" f
+        " = "
+        proto-num (get "number" f)
+        proto-field-options f
+        ";"
+
+; A field's statement: a field, a map field, or a group with its body. A
+; group outside a oneof is written with the body the message's own were
+; written with; one in a oneof, a level deeper, has its body written there.
+def proto-field-statement [self syntax indent ns bodies att fs k labelled]
+  let [f (proto-at fs k)]
+    let [t (proto-at att k)]
+      match (proto-less t 0)
+        case true (proto-field-line syntax indent f labelled)
+        case false
+          match (get "type" f)
+            case "TYPE_GROUP"
+              match labelled
+                case true (proto-group-block syntax indent f (proto-at bodies t) labelled)
+                case false (proto-group-block syntax indent f (self self syntax (proto-deeper indent) (proto-at ns t)) labelled)
+            case _ (proto-map-line indent f (proto-at ns t))
+
+def proto-unit-text [self syntax indent m ns bodies fs att j]
+  let [f (proto-at fs j)]
+    match (proto-in-oneof f)
+      case false (proto-field-statement self syntax indent ns bodies att fs j true)
+      case true
+        proto-oneof-block indent m (get "oneofIndex" f)
+          string-join "\\n"
+            map (fn [k] (proto-field-statement self syntax (proto-deeper indent) ns bodies att fs k false)) (proto-unit-fields fs j)
+
+def proto-unit [self syntax indent m ns bodies fs att j]
+  match (proto-unit-start fs j)
+    case false ""
+    case true
+      proto-lines
+        vector
+          proto-nested-before indent ns bodies fs att j
+          proto-oneofs-before indent m fs j
+          proto-unit-text self syntax indent m ns bodies fs att j
+
+; A message's extension ranges, reserved ranges and reserved names, in the
+; order the tree holds them.
+def proto-range-key [syntax indent maxv m k]
+  match k
+    case "extensionRange"
+      string-join "\\n"
+        map
+          fn [r]
+            string-join "" [indent "extensions " (proto-range-ex maxv r) (proto-plain-options r) ";"]
+          proto-list "extensionRange" m
+    case "reservedRange" (proto-reserved-ranges indent (string-join ", " (map (fn [r] (proto-range-ex maxv r)) (proto-list "reservedRange" m))))
+    case "reservedName" (proto-reserved-names syntax indent (proto-list "reservedName" m))
+    case _ ""
+
+; A message's body, the one definition the render recurses through, as
+; \`self\`. Every nested type's body is written first, a level deeper, and
+; the rest of the body places them: the recursion then nests a few
+; evaluation levels a message level, well within alchemy's bound for the
+; 100 levels the reader accepts, where placing a message among the fields
+; first would nest some twenty.
+def proto-message-body [self syntax indent m]
+  let [ns (proto-list "nestedType" m)]
+    let [bodies (map (fn [n] (self self syntax (proto-deeper indent) n)) ns)]
+      proto-message-parts self syntax indent m ns bodies
+
+def proto-message-parts [self syntax indent m ns bodies]
+  let [fs (proto-list "field" m)]
+    let [att (map (fn [f] (proto-attached ns f)) fs)]
+      proto-lines
+        vector
+          proto-option-lines indent (proto-record "options" m)
+          proto-lines (map (fn [j] (proto-unit self syntax indent m ns bodies fs att j)) (indices fs))
+          proto-nested-after indent ns bodies att
+          proto-oneofs-after indent m
+          string-join "\\n" (map (fn [e] (proto-enum syntax indent e)) (proto-list "enumType" m))
+          string-join "\\n" (map (fn [f] (proto-extend syntax indent f)) (proto-list "extension" m))
+          proto-lines (map (fn [k] (proto-range-key syntax indent (proto-max m) m k)) (keys m))
+
+; A message's block around its body.
+def proto-message [indent m body]
+  proto-block indent (string-join "" [(proto-visibility m) "message " (proto-name "a message" m)]) body
+
+; ---- enums, services, extensions
+
+def proto-enum-key [syntax indent e k]
+  match k
+    case "value"
+      string-join "\\n"
+        map
+          fn [v]
+            string-join "" [indent (proto-name "an enum value" v) " = " (proto-num (get "number" v)) (proto-plain-options v) ";"]
+          proto-list "value" e
+    case "options" (proto-option-lines indent (proto-record "options" e))
+    case "reservedRange" (proto-reserved-ranges indent (string-join ", " (map proto-range-in (proto-list "reservedRange" e))))
+    case "reservedName" (proto-reserved-names syntax indent (proto-list "reservedName" e))
+    case _ ""
+
+def proto-enum [syntax indent e]
+  proto-block indent (string-join "" [(proto-visibility e) "enum " (proto-name "an enum" e)])
+    proto-lines (map (fn [k] (proto-enum-key syntax (proto-deeper indent) e k)) (keys e))
+
+def proto-stream [flag]
+  match flag
+    case true "stream "
+    case _ ""
+
+def proto-method [indent r]
+  let [head (string-join "" ["rpc " (proto-name "a method" r) " (" (proto-stream (get "clientStreaming" r)) (proto-text "a method" "inputType" r) ") returns (" (proto-stream (get "serverStreaming" r)) (proto-text "a method" "outputType" r) ")"])]
+    match (proto-has "options" r)
+      case false (string-join "" [indent head ";"])
+      case true (proto-block indent head (proto-option-lines (proto-deeper indent) (proto-record "options" r)))
+
+def proto-service [indent s]
+  proto-block indent (string-join "" ["service " (proto-name "a service" s)])
+    proto-lines
+      vector
+        proto-option-lines (proto-deeper indent) (proto-record "options" s)
+        string-join "\\n" (map (fn [r] (proto-method (proto-deeper indent) r)) (proto-list "method" s))
+
+; An extension, in an \`extend\` block of its own.
+def proto-extend [syntax indent f]
+  proto-block indent (string-join "" ["extend " (proto-text "an extension" "extendee" f)])
+    proto-field-line syntax (proto-deeper indent) f true
+
+; ---- the file
+
+def proto-syntax-line [file]
+  match (get "syntax" file)
+    case "proto2" "syntax = \\"proto2\\";"
+    case "proto3" "syntax = \\"proto3\\";"
+    case "editions"
+      match (get "edition" file)
+        case "EDITION_2023" "edition = \\"2023\\";"
+        case "EDITION_2024" "edition = \\"2024\\";"
+        case _ (fail :unrepresentable "the tree is not a FileDescriptorProto: its edition is not one a .proto file declares")
+    case _ (fail :unrepresentable "the tree is not a FileDescriptorProto: its syntax is not proto2, proto3 or editions")
+
+def proto-import-kind [file i]
+  match (proto-member i (proto-list "publicDependency" file))
+    case true "public "
+    case false
+      match (proto-member i (proto-list "weakDependency" file))
+        case true "weak "
+        case false ""
+
+def proto-dependency [file i d]
+  match (kind d)
+    case :string (string-join "" ["import " (proto-import-kind file i) (proto-literal d) ";"])
+    case _ (fail :unrepresentable "the tree is not a FileDescriptorProto: an import is not a string")
+
+; The package, the imports and the file's options, in the order the tree
+; holds them.
+def proto-head-key [file k]
+  match k
+    case "package" (string-join "" ["package " (proto-text "the file" "package" file) ";"])
+    case "dependency"
+      let [ds (proto-list "dependency" file)]
+        string-join "\\n" (map (fn [i] (proto-dependency file i (proto-at ds i))) (indices ds))
+    case "optionDependency"
+      string-join "\\n"
+        map
+          fn [d]
+            string-join "" ["import option " (proto-literal d) ";"]
+          proto-list "optionDependency" file
+    case "options" (proto-option-lines "" (proto-record "options" file))
+    case _ ""
+
+def proto-file [file]
+  match (kind file)
+    case :record
+      let [syntax (get "syntax" file)]
+        string-join ""
+          vector
+            proto-lines
+              vector
+                proto-syntax-line file
+                proto-lines (map (fn [k] (proto-head-key file k)) (keys file))
+                string-join "\\n" (map (fn [m] (proto-message "" m (proto-message-body proto-message-body syntax "  " m))) (proto-list "messageType" file))
+                string-join "\\n" (map (fn [e] (proto-enum syntax "" e)) (proto-list "enumType" file))
+                string-join "\\n" (map (fn [s] (proto-service "" s)) (proto-list "service" file))
+                string-join "\\n" (map (fn [f] (proto-extend syntax "" f)) (proto-list "extension" file))
+            "\\n"
+    case _ (fail :unrepresentable "the tree is not a FileDescriptorProto: its root is not an object")
+
+; The render: the tree's events in, the file's text out.
+def proto-render [input]
+  concat-map proto-file
+    select root
+      as-events (scan-emit :other proto-mark-step proto-mark-finish (events input))
+` })
+});
+function translate() {
+    return TRANSLATION;
+}
+//# sourceMappingURL=translate.js.map