🥮 mooncakes.io

moon_proto

A MoonBit protobuf ecosystem lab for dynamic schema validation, compatibility testing, and AI code verification.

protobuf
schema
verification
codegen
wasm
moon add 123123213weqw/moon_proto@0.1.1
Download zip
Version
0.1.1
License
MIT
Repository
Last updated
last month
Downloads
15
README

#Moon Proto Lab

CI Mooncakes MoonBit License

Moon Proto Lab 是面向 MoonBit protobuf 生态的 schema 验证、兼容性检查与 AI 代码验证工具链。

它把 .proto 从“看起来正确的文本”变成可诊断、可生成、可编译、可回归、可报告的工程资产：

.proto -> Schema Doctor -> compatibility check -> dynamic binary/JSON runtime
       -> MoonBit codegen -> generated-code compile -> Markdown/JUnit/CI evidence

本项目不替代现有的 moonbitlang/protobuf 或 moonbitlang/protoc-gen-mbt。它提供的是围绕官方 protobuf 栈的验证与工具层，重点解决 AI 生成 schema/代码难以确认、schema 演进容易破坏兼容性、生成代码缺少持续验证等问题。

#30 秒快速开始

#作为 MoonBit 库安装

moon add 123123213weqw/moon_proto

在使用该库的 moon.pkg 中导入：

import {
  "123123213weqw/moon_proto" @proto,
}

最小示例：

fn main {
  let encoded = @proto.encode_varint_u64(300UL)
  println(encoded.length()) // 2
}

#使用完整验证工具

git clone https://github.com/123123213weqw/moon_proto.git
cd moon_proto

# 检查 AI/人工生成的 schema
python3 scripts/moon_proto_lab.py doctor examples/ai/good_order.proto

# 完成 doctor、inspect、codegen、生成代码编译并输出报告
python3 scripts/moon_proto_lab.py verify \
  examples/ai/good_order.proto \
  --report generated/verify_report.md \
  --junit-out generated/verify_report.xml

# 检查 old/new schema 是否兼容
python3 scripts/moon_proto_lab.py compat \
  examples/ai/good_order.proto \
  examples/ai/good_order_v2.proto \
  --report generated/compat_report.md

完整本地验收：

bash scripts/release_gate.sh

运行要求：MoonBit；文件版报告工具需要 Python 3；完整跨语言 oracle 还需要 Python protobuf 与 Go。

#Agent 反馈闭环

下图展示 AI Agent 生成 schema 后，Moon Proto Lab 如何返回稳定诊断并驱动修复。它是工作流说明图；后面的终端图来自仓库真实命令记录。

#实际运行证据

每张图都有同名 .txt 命令记录，可核对命令、工作目录、时间和退出码。

补充证据：moon test --target all、moon package、Schema Doctor 负例。

#核心能力

能力当前实现
Wire/runtimevarint、zig-zag、fixed32/64、length-delimited、unknown-field skip
Schemaproto3 message、enum、optional/repeated、map、oneof、reserved、nested type、常见声明容错
动态消息descriptor-driven scalar、repeated、packed、enum、nested、map、oneof 二进制编解码
Protobuf JSONenum name、64-bit integer、base64、Unicode、lowerCamel、map key normalization、严格数字语法
Schema Doctor字段号/名称冲突、enum 规则、map 约束、reserved 复用等稳定诊断
兼容性检查old/new .proto 与 FileDescriptorSet 的破坏性变更检查
CodegenMoonBit struct、enum、descriptor、动态 runtime helper，并执行真实 moon check
工程证据Python/Go oracle、建模的 conformance-lite 用例、官方接口契约检查、Markdown/JSON/JUnit 报告
Registry adapterdescriptor registry、release policy、文件/HTTP/profile/GitHub Contents 适配验证

#一个完整场景

故意错误的 schema：

syntax = "proto3";
message Order {
  reserved 7;
  reserved "legacy_note";
  uint64 id = 1;
  string duplicate = 1;
  bytes legacy_note = 7;
  map<bytes, string> invalid_labels = 8;
}

运行：

python3 scripts/moon_proto_lab.py doctor examples/ai/bad_order.proto

输出包含稳定路径：

schema invalid
issues: 6
message.Order.field.1: duplicate field number
message.Order.field.invalid_labels.key: invalid map key type
message.Order.field.legacy_note.number: field uses reserved number
message.Order.field.legacy_note.name: field uses reserved name

修复后再执行 verify 与 compat，生成代码必须真实编译，schema 演进也必须通过兼容性门禁。

#MoonBit API 示例

let desc = @proto.MessageDescriptor::{
  name: "User",
  fields: [
    @proto.FieldDescriptor::{
      name: "id",
      typ: @proto.UInt64Type,
      number: 1,
      label: @proto.Singular,
    },
    @proto.FieldDescriptor::{
      name: "name",
      typ: @proto.StringType,
      number: 2,
      label: @proto.Singular,
    },
  ],
}

let msg = @proto.message_value([
  @proto.message_field("id", @proto.UInt64Value(150UL)),
  @proto.message_field("name", @proto.StringValue("Alice")),
])

let encoded = @proto.encode_message(desc, msg)

#验证与质量

当前提交线的可复现结果：

  • moon check --deny-warn：通过；
  • moon test --deny-warn：60/60 passed；
  • moon test --target all：wasm、wasm-gc、JS、native 全通过；
  • MoonBit 核心包行覆盖率：1935/2388，约 81.0%；
  • generated-code compile check：通过；
  • Python/Go protobuf oracle：通过；
  • AI schema 正例、兼容演进与故意错误负例：通过；
  • GitHub Actions：通过。

常用命令：

moon fmt --check
moon info
moon package --list
moon check --deny-warn
moon build
moon test --deny-warn
moon test --target all
moon coverage analyze -p 123123213weqw/moon_proto -- -f summary
tests/codegen/compile_generated.sh

#与现有 MoonBit protobuf 项目的关系

MoonBit 生态已有：

Moon Proto Lab 的独立贡献是：

  1. 在生成前检查 schema，并为 AI 输出提供稳定诊断；
  2. 在 schema 演进时检查字段号、类型、reserved 等兼容性合同；
  3. 在生成后真实编译 MoonBit 代码，而不是只做文本快照；
  4. 使用 Python/Go oracle 与 MoonBit golden tests 验证 wire/JSON 行为；
  5. 输出适合 CI、代码审查和 Agent 消费的 Markdown/JSON/JUnit 证据。

#已知边界

当前版本是面向验证场景的 proto3 子集，不宣称完整 protobuf conformance：

  • service、rpc、custom option 等主要做解析容错，不生成完整 RPC 实现；
  • typed struct 的生产级 encode/decode 能力不替代官方生成器，核心验证路径使用动态 MessageValue；
  • conformance-lite 是基于公开 protobuf 语义建模的小型 fixture 集，不是上游官方 conformance suite 的镜像；
  • official source/output-shape contract 检查验证公开接口契约；只有显式启用 live-generator 路径时才会实际运行官方生成器；
  • FileDescriptorSet、报告和 registry adapter 目前由 Python 集成层承载，MoonBit 核心实现集中在 parser/runtime/JSON/codegen/compat CLI。

#文档

#仓库与发布

#License

项目原创代码采用 MIT License。第三方依赖、公开规范、测试 oracle 和契约 fixture 的来源与许可证见 THIRD_PARTY_NOTICES.md。

#
CodegenOptions

source
pub(all) struct CodegenOptions {
  emit_descriptor_functions : Bool
  emit_runtime_helpers : Bool
} derive(Eq, 
Debug)

Options for emitting MoonBit source from a parsed proto file.

#
CodegenOptions::default

source

Default generator settings used by examples and tests.

#
DecodeBytesResult

source
pub(all) enum DecodeBytesResult {
  BytesOk(Bytes, Int)
  BytesErr(DecodeError)
} derive(Eq, 
Debug)

Result of reading a length-delimited payload.

#
DecodeError

source
pub(all) enum DecodeError {
  UnexpectedEof
  VarintOverflow
  InvalidWireType(Int)
  InvalidFieldNumber(Int)
  NegativeLength
  Unsupported(String)
} derive(Eq, 
Debug)

Error values returned by the small, allocation-light protobuf readers.

#
DecodeMessageResult

source
pub(all) enum DecodeMessageResult {
  DecodeMessageOk(MessageValue, Int)
  DecodeMessageErr(DecodeError)
} derive(Eq, 
Debug)

offset after the decoded message.

#
DecodeStringResult

source
pub(all) enum DecodeStringResult {
  StringOk(String, Int)
  StringErr(DecodeError)
} derive(Eq, 
Debug)

Result of reading a string.

#
DecodeU32Result

source
pub(all) enum DecodeU32Result {
  U32Ok(UInt, Int)
  U32Err(DecodeError)
} derive(Eq, 
Debug)

Result of reading a 32-bit little-endian fixed value.

#
DecodeU64FixedResult

source
pub(all) enum DecodeU64FixedResult {
  U64FixedOk(UInt64, Int)
  U64FixedErr(DecodeError)
} derive(Eq, 
Debug)

Result of reading a 64-bit little-endian fixed value.

#
DecodeU64Result

source
pub(all) enum DecodeU64Result {
  U64Ok(UInt64, Int)
  U64Err(DecodeError)
} derive(Eq, 
Debug)

Result of reading an unsigned protobuf varint.

#
EncodeMessageResult

source
pub(all) enum EncodeMessageResult {
  EncodeMessageOk(Bytes)
  EncodeMessageErr(DecodeError)
} derive(Eq, 
Debug)

Result of encoding a dynamic message.

#
EnumDescriptor

source
pub(all) struct EnumDescriptor {
  name : String
  values : Array[EnumValueDescriptor]
  allow_alias : Bool
} derive(Eq, 
Debug)

A parsed enum descriptor.

#
EnumValueDescriptor

source
pub(all) struct EnumValueDescriptor {
  name : String
  number : Int
} derive(Eq, 
Debug)

A parsed enum value descriptor.

#
FieldDescriptor

source
pub(all) struct FieldDescriptor {
  name : String
  typ : ScalarType
  number : Int
  label : FieldLabel
} derive(Eq, 
Debug)

A parsed field descriptor.

#
FieldLabel

source
pub(all) enum FieldLabel {
  Singular
  Optional
  Repeated
  Oneof(String)
} derive(Eq, 
Debug)

Field cardinality as written in a proto3 schema.

#
JsonDecodeResult

source
pub(all) enum JsonDecodeResult {
  JsonDecodeOk(MessageValue)
  JsonDecodeErr(DecodeError)
} derive(Eq, 
Debug)

Result of parsing protobuf-style JSON into a dynamic message.

#
JsonEncodeResult

source
pub(all) enum JsonEncodeResult {
  JsonOk(String)
  JsonErr(DecodeError)
} derive(Eq, 
Debug)

Result of converting a dynamic message to protobuf-style JSON.

#
MessageDescriptor

source
pub(all) struct MessageDescriptor {
  name : String
  fields : Array[FieldDescriptor]
} derive(Eq, 
Debug)

A parsed message descriptor.

#
MessageField

source
pub(all) struct MessageField {
  name : String
  values : Array[ProtoValue]
} derive(Eq, 
Debug)

one value.

#
MessageValue

source
pub(all) struct MessageValue {
  fields : Array[MessageField]
} derive(Eq, 
Debug)

Dynamic message value consumed and produced by the schema-driven runtime.

#
ParseKeyResult

source
pub(all) enum ParseKeyResult {
  KeyOk(Int, WireType)
  KeyErr(DecodeError)
} derive(Eq, 
Debug)

Result of splitting a protobuf key into field number and wire type.

#
ParseProtoResult

source
pub(all) enum ParseProtoResult {
  ProtoOk(ProtoFile)
  ProtoErr(SchemaError)
} derive(Eq, 
Debug)

Result of parsing a proto file.

#
ProtoFile

source
pub(all) struct ProtoFile {
  syntax : String
  package_name : String
  messages : Array[MessageDescriptor]
  enums : Array[EnumDescriptor]
  message_reservations : Array[ReservedDescriptor]
  enum_reservations : Array[ReservedDescriptor]
} derive(Eq, 
Debug)

Top-level proto file model used by parser and codegen.

#
ProtoFile::empty

source
fn ProtoFile::empty() -> ProtoFile

Empty proto file constructor used by tests and future codegen.

#
ProtoToken

source
pub(all) enum ProtoToken {
  Ident(String)
  IntLit(Int)
  StrLit(String)
  Sym(String)
} derive(Eq, 
Debug)

Tokens for a deliberately small proto3 parser.

#
ProtoValue

source
pub(all) enum ProtoValue {
  UInt64Value(UInt64)
  Int64Value(Int64)
  FloatValue(Float)
  DoubleValue(Double)
  BoolValue(Bool)
  StringValue(String)
  BytesValue(Bytes)
  NestedMessageValue(MessageValue)
  MapEntryValue(MessageValue)
} derive(Eq, 
Debug)

fixed32/fixed64 without a large amount of boxing.

#
ReservedDescriptor

source
pub(all) struct ReservedDescriptor {
  owner : String
  numbers : Array[ReservedNumberRange]
  names : Array[String]
} derive(Eq, 
Debug)

Reserved numbers/names attached to a top-level message or enum.

#
ReservedNumberRange

source
pub(all) struct ReservedNumberRange {
  start : Int
  end : Int
} derive(Eq, 
Debug)

A reserved numeric interval written by a proto reserved declaration.

#
ScalarType

source
pub(all) enum ScalarType {
  DoubleType
  FloatType
  Int32Type
  Int64Type
  UInt32Type
  UInt64Type
  SInt32Type
  SInt64Type
  Fixed32Type
  Fixed64Type
  SFixed32Type
  SFixed64Type
  BoolType
  StringType
  BytesType
  EnumType(String)
  NamedType(String)
  MapType(ScalarType, ScalarType)
} derive(Eq, 
Debug)

Proto3 scalar types supported by the stage-1 runtime/codegen plan.

#
ScalarType::wire_type

source
fn ScalarType::wire_type(self : ScalarType) -> WireType

Map a scalar type to its protobuf wire type.

#
SchemaError

source
pub(all) enum SchemaError {
  Expected(String)
  UnexpectedEofInSchema
} derive(Eq, 
Debug)

Parser error type for schema parsing.

#
SchemaIssue

source
pub(all) struct SchemaIssue {
  path : String
  message : String
} derive(Eq, 
Debug)

One schema validation issue with a stable path for diagnostics.

#
SchemaValidationResult

source
pub(all) enum SchemaValidationResult {
  SchemaValid
  SchemaInvalid(Array[SchemaIssue])
} derive(Eq, 
Debug)

Result of validating a proto schema model.

#
WireType

source
pub(all) enum WireType {
  Varint
  Fixed64
  LengthDelimited
  StartGroup
  EndGroup
  Fixed32
} derive(Eq, 
Debug)

Protobuf wire type numbers as defined by the encoding specification.

#
WireType::number

source
fn WireType::number(self : WireType) -> Int

Numeric tag used in the low three bits of a protobuf key.

#
base64_decode

source
fn base64_decode(input : String) -> DecodeBytesResult

Decode base64 used by protobuf JSON bytes fields. In addition to the standard alphabet, protobuf JSON parsers accept URL-safe -/_ variants and missing final padding.

#
base64_encode

source
fn base64_encode(input : Bytes) -> String

Encode bytes with the standard base64 alphabet used by protobuf JSON.

#
concat_bytes

source
fn concat_bytes(parts : Array[Bytes]) -> Bytes

Concatenate byte buffers without exposing mutable implementation details.

#
decode_fixed32

source
fn decode_fixed32(input : Bytes, offset? : Int) -> DecodeU32Result

Decode a fixed32 value from protobuf little-endian order.

#
decode_fixed64

source
fn decode_fixed64(input : Bytes, offset? : Int) -> DecodeU64FixedResult

Decode a fixed64 value from protobuf little-endian order.

#
decode_length_delimited

source
fn decode_length_delimited(input : Bytes, offset? : Int) -> DecodeBytesResult

Decode a length-delimited payload from input.

#
decode_message

source
fn decode_message(desc : MessageDescriptor, input : Bytes, offset? : Int) -> DecodeMessageResult

singular fields keep the last value.

#
decode_message_with_descriptors

source
fn decode_message_with_descriptors(desc : MessageDescriptor, descriptors : Array[MessageDescriptor], input : Bytes, offset? : Int) -> DecodeMessageResult

Decode a dynamic message, resolving NamedType fields through descriptors for message-valued nested fields.

#
decode_string_lossy

source
fn decode_string_lossy(input : Bytes, offset? : Int) -> DecodeStringResult

Decode a UTF-8 string lossily from length-delimited protobuf data.

#
decode_varint_u64

source
fn decode_varint_u64(input : Bytes, offset? : Int) -> DecodeU64Result

Decode a UInt64 varint from input starting at offset.

#
decode_zigzag_i64

source
fn decode_zigzag_i64(value : UInt64) -> Int64

Decode a zig-zag UInt64 into Int64.

#
decode_zigzag_int

source
fn decode_zigzag_int(value : UInt) -> Int

Decode a zig-zag UInt into an Int.

#
encode_bool_field

source
fn encode_bool_field(field_number : Int, value : Bool) -> Bytes

Encode a bool field payload with its key.

#
encode_bytes_field

source
fn encode_bytes_field(field_number : Int, value : Bytes) -> Bytes

Encode a bytes field payload with its key.

#
encode_fixed32

source
fn encode_fixed32(value : UInt) -> Bytes

Encode a fixed32 value in protobuf little-endian order.

#
encode_fixed64

source
fn encode_fixed64(value : UInt64) -> Bytes

Encode a fixed64 value in protobuf little-endian order.

#
encode_key

source
fn encode_key(field_number : Int, wire : WireType) -> Bytes

Encode a key as a protobuf varint.

#
encode_length_delimited

source
fn encode_length_delimited(payload : Bytes) -> Bytes

Encode a length-delimited payload: varint length followed by bytes.

#
encode_message

source
fn encode_message(desc : MessageDescriptor, value : MessageValue) -> EncodeMessageResult

golden-vector tests easy to read.

#
encode_message_with_descriptors

source
fn encode_message_with_descriptors(desc : MessageDescriptor, descriptors : Array[MessageDescriptor], value : MessageValue) -> EncodeMessageResult

Encode a dynamic message, resolving NamedType fields through descriptors for message-valued nested fields.

#
encode_sint64_field

source
fn encode_sint64_field(field_number : Int, value : Int64) -> Bytes

Encode a sint64 field payload with protobuf zig-zag mapping and key.

#
encode_string

source
fn encode_string(value : String) -> Bytes

Encode a UTF-8 string as length-delimited protobuf data.

#
encode_string_field

source
fn encode_string_field(field_number : Int, value : String) -> Bytes

Encode a string field payload with its key.

#
encode_uint64_field

source
fn encode_uint64_field(field_number : Int, value : UInt64) -> Bytes

Encode uint32/uint64 field payload with its key.

#
encode_varint_u64

source
fn encode_varint_u64(value : UInt64) -> Bytes

Encode a UInt64 using protobuf's unsigned base-128 varint format.

#
encode_varint_uint

source
fn encode_varint_uint(value : UInt) -> Bytes

Encode a UInt32/UInt as a protobuf varint.

#
encode_zigzag_i64

source
fn encode_zigzag_i64(value : Int64) -> UInt64

Encode an Int64 with protobuf zig-zag mapping.

#
encode_zigzag_int

source
fn encode_zigzag_int(value : Int) -> UInt

Encode a signed 32-bit-ish Int with protobuf zig-zag mapping.

#
generate_descriptor_function

source
fn generate_descriptor_function(desc : MessageDescriptor) -> String

code and passed back to encode_message / decode_message.

#
generate_enum

source
fn generate_enum(desc : EnumDescriptor) -> String

Emit a MoonBit enum declaration for one enum descriptor.

#
generate_enum_descriptor_function

source
fn generate_enum_descriptor_function(desc : EnumDescriptor) -> String

Emit a descriptor function for one enum descriptor.

#
generate_enum_descriptor_registry

source
fn generate_enum_descriptor_registry(file : ProtoFile) -> String

Emit a registry function used by generated JSON helpers to resolve enum descriptors and render protobuf JSON enum names.

#
generate_message_descriptor_registry

source
fn generate_message_descriptor_registry(file : ProtoFile) -> String

Emit a registry function used by generated runtime helpers to resolve nested message descriptors.

#
generate_message_runtime_helpers

source
fn generate_message_runtime_helpers(desc : MessageDescriptor) -> String

Emit dynamic encode/decode/JSON helper functions for one generated message.

#
generate_message_struct

source
fn generate_message_struct(desc : MessageDescriptor) -> String

Emit a MoonBit struct declaration for one message descriptor.

#
generate_moonbit_source

source
fn generate_moonbit_source(file : ProtoFile, options? : CodegenOptions) -> String

Generate MoonBit declarations for all messages in a parsed proto file.

#
is_valid_field_number

source
fn is_valid_field_number(number : Int) -> Bool

Protobuf field numbers must be positive, at most 2^29 - 1, and must not fall inside the implementation-reserved 19000..19999 range.

#
is_valid_map_key_type

source
fn is_valid_map_key_type(typ : ScalarType) -> Bool

Protobuf map keys may be integral, bool or string scalar types.

#
json_escape_string

source
fn json_escape_string(value : String) -> String

Escape a MoonBit string as a JSON string literal.

#
json_to_message

source
fn json_to_message(desc : MessageDescriptor, input : String) -> JsonDecodeResult

Parse a protobuf-style JSON object into a dynamic message. Known fields are accepted in any JSON order and returned in descriptor order.

#
json_to_message_with_descriptors

source
fn json_to_message_with_descriptors(desc : MessageDescriptor, descriptors : Array[MessageDescriptor], input : String) -> JsonDecodeResult

Parse protobuf-style JSON, resolving NamedType fields through descriptors for nested message values.

#
json_to_message_with_schema

source
fn json_to_message_with_schema(desc : MessageDescriptor, descriptors : Array[MessageDescriptor], enum_descriptors : Array[EnumDescriptor], input : String) -> JsonDecodeResult

Parse protobuf-style JSON while resolving both nested message descriptors and enum value names.

#
lex_proto

source
fn lex_proto(src : String) -> Array[ProtoToken]

Lex a useful proto3 subset: identifiers, integers, strings and punctuation.

#
make_key

source
fn make_key(field_number : Int, wire : WireType) -> UInt64

Build a protobuf key: (field_number << 3) | wire_type.

#
map_entry_value

source
fn map_entry_value(key : ProtoValue, value : ProtoValue) -> ProtoValue

Convenience constructor for a protobuf map entry value. Map fields are represented as repeated MapEntryValue items in the dynamic API.

#
message_field

source
fn message_field(name : String, value : ProtoValue) -> MessageField

Convenience constructor for a singular field.

#
message_to_json

source
fn message_to_json(desc : MessageDescriptor, value : MessageValue) -> JsonEncodeResult

Convert a dynamic message to deterministic protobuf-style JSON. Known fields are emitted in descriptor order; absent fields are omitted.

#
message_to_json_lower_camel

source
fn message_to_json_lower_camel(desc : MessageDescriptor, value : MessageValue) -> JsonEncodeResult

Convert a dynamic message to deterministic protobuf-style JSON using lowerCamelCase JSON field names, matching the protobuf JSON default.

#
message_to_json_lower_camel_with_descriptors

source
fn message_to_json_lower_camel_with_descriptors(desc : MessageDescriptor, descriptors : Array[MessageDescriptor], value : MessageValue) -> JsonEncodeResult

Convert protobuf-style JSON with lowerCamelCase field names while resolving NamedType fields through descriptors.

#
message_to_json_lower_camel_with_schema

source
fn message_to_json_lower_camel_with_schema(desc : MessageDescriptor, descriptors : Array[MessageDescriptor], enum_descriptors : Array[EnumDescriptor], value : MessageValue) -> JsonEncodeResult

Convert lowerCamelCase protobuf-style JSON using enum value names when matching EnumDescriptors are available.

#
message_to_json_with_descriptors

source
fn message_to_json_with_descriptors(desc : MessageDescriptor, descriptors : Array[MessageDescriptor], value : MessageValue) -> JsonEncodeResult

Convert a dynamic message to deterministic protobuf-style JSON, resolving NamedType fields through descriptors for nested message values.

#
message_to_json_with_schema

source
fn message_to_json_with_schema(desc : MessageDescriptor, descriptors : Array[MessageDescriptor], enum_descriptors : Array[EnumDescriptor], value : MessageValue) -> JsonEncodeResult

Convert protobuf-style JSON using enum value names when matching EnumDescriptors are available.

#
message_value

source
fn message_value(fields : Array[MessageField]) -> MessageValue

Convenience constructor for a dynamic message.

#
parse_key

source
fn parse_key(raw : UInt64) -> ParseKeyResult

Parse a raw protobuf key varint value.

#
parse_proto

source
fn parse_proto(src : String) -> ParseProtoResult

Parse a proto3 subset: syntax/package declarations, messages, fields and top-level enums.

#
repeated_message_field

source
fn repeated_message_field(name : String, values : Array[ProtoValue]) -> MessageField

Convenience constructor for a repeated field.

#
scalar_type_from_string

source
fn scalar_type_from_string(name : String) -> ScalarType

Convert a schema type token into a scalar or named message type.

#
schema_is_valid

source
fn schema_is_valid(file : ProtoFile) -> Bool

#
validate_enum_descriptor

source
fn validate_enum_descriptor(enum_desc : EnumDescriptor) -> SchemaValidationResult

#
validate_message_descriptor

source
fn validate_message_descriptor(message : MessageDescriptor) -> SchemaValidationResult

#
validate_proto_file

source
fn validate_proto_file(file : ProtoFile) -> SchemaValidationResult

#
wire_type_from_number

source
fn wire_type_from_number(n : Int) -> WireType?

Convert a raw wire type number to a typed value.

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io