@bufbuild/protobuf 0.0.1 → 0.0.2-alpha.3

package/dist/esm/proto-base64.js

@@ -0,0 +1,135 @@
+// Copyright 2021-2022 Buf Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+/* eslint-disable @typescript-eslint/ban-ts-comment, @typescript-eslint/no-unnecessary-condition, prefer-const */
+// lookup table from base64 character to byte
+let encTable = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");
+// lookup table from base64 character *code* to byte because lookup by number is fast
+let decTable = [];
+for (let i = 0; i < encTable.length; i++)
+    decTable[encTable[i].charCodeAt(0)] = i;
+// support base64url variants
+decTable["-".charCodeAt(0)] = encTable.indexOf("+");
+decTable["_".charCodeAt(0)] = encTable.indexOf("/");
+export const protoBase64 = {
+    /**
+     * Decodes a base64 string to a byte array.
+     *
+     * - ignores white-space, including line breaks and tabs
+     * - allows inner padding (can decode concatenated base64 strings)
+     * - does not require padding
+     * - understands base64url encoding:
+     *   "-" instead of "+",
+     *   "_" instead of "/",
+     *   no padding
+     */
+    dec(base64Str) {
+        // estimate byte size, not accounting for inner padding and whitespace
+        let es = (base64Str.length * 3) / 4;
+        // if (es % 3 !== 0)
+        // throw new Error("invalid base64 string");
+        if (base64Str[base64Str.length - 2] == "=")
+            es -= 2;
+        else if (base64Str[base64Str.length - 1] == "=")
+            es -= 1;
+        let bytes = new Uint8Array(es), bytePos = 0, // position in byte array
+        groupPos = 0, // position in base64 group
+        b, // current byte
+        p = 0; // previous byte
+        for (let i = 0; i < base64Str.length; i++) {
+            b = decTable[base64Str.charCodeAt(i)];
+            if (b === undefined) {
+                switch (base64Str[i]) {
+                    // @ts-ignore TS7029: Fallthrough case in switch
+                    case "=":
+                        groupPos = 0; // reset state when padding found
+                    // @ts-ignore TS7029: Fallthrough case in switch
+                    case "\n":
+                    case "\r":
+                    case "\t":
+                    case " ":
+                        continue; // skip white-space, and padding
+                    default:
+                        throw Error("invalid base64 string.");
+                }
+            }
+            switch (groupPos) {
+                case 0:
+                    p = b;
+                    groupPos = 1;
+                    break;
+                case 1:
+                    bytes[bytePos++] = (p << 2) | ((b & 48) >> 4);
+                    p = b;
+                    groupPos = 2;
+                    break;
+                case 2:
+                    bytes[bytePos++] = ((p & 15) << 4) | ((b & 60) >> 2);
+                    p = b;
+                    groupPos = 3;
+                    break;
+                case 3:
+                    bytes[bytePos++] = ((p & 3) << 6) | b;
+                    groupPos = 0;
+                    break;
+            }
+        }
+        if (groupPos == 1)
+            throw Error("invalid base64 string.");
+        return bytes.subarray(0, bytePos);
+    },
+    /**
+     * Decodes a base64 string to a byte array.
+     *
+     * - ignores white-space, including line breaks and tabs
+     * - allows inner padding (can decode concatenated base64 strings)
+     * - does not require padding
+     * - understands base64url encoding:
+     *   "-" instead of "+",
+     *   "_" instead of "/",
+     *   no padding
+     */
+    enc(bytes) {
+        let base64 = "", groupPos = 0, // position in base64 group
+        b, // current byte
+        p = 0; // carry over from previous byte
+        for (let i = 0; i < bytes.length; i++) {
+            b = bytes[i];
+            switch (groupPos) {
+                case 0:
+                    base64 += encTable[b >> 2];
+                    p = (b & 3) << 4;
+                    groupPos = 1;
+                    break;
+                case 1:
+                    base64 += encTable[p | (b >> 4)];
+                    p = (b & 15) << 2;
+                    groupPos = 2;
+                    break;
+                case 2:
+                    base64 += encTable[p | (b >> 6)];
+                    base64 += encTable[b & 63];
+                    groupPos = 0;
+                    break;
+            }
+        }
+        // padding required?
+        if (groupPos) {
+            base64 += encTable[p];
+            base64 += "=";
+            if (groupPos == 1)
+                base64 += "=";
+        }
+        return base64;
+    },
+};

package/dist/esm/proto-int64.js

@@ -1,4 +1,17 @@
-import { int64fromString, int64toString } from "./private/goog-varint.js";
+// Copyright 2021-2022 Buf Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import { int64fromString, int64toString } from "./google/varint.js";
 function makeInt64Support() {
     const dv = new DataView(new ArrayBuffer(8));
     // note that Safari 14 implements BigInt, but not the DataView methods

package/dist/esm/proto2.js

@@ -1,3 +1,16 @@
+// Copyright 2021-2022 Buf Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 import { makeProtoRuntime } from "./private/proto-runtime.js";
 import { makeBinaryFormatProto2 } from "./private/binary-format-proto2.js";
 import { makeUtilCommon } from "./private/util-common.js";

package/dist/esm/proto3.js

@@ -1,3 +1,16 @@
+// Copyright 2021-2022 Buf Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 import { makeProtoRuntime } from "./private/proto-runtime.js";
 import { makeBinaryFormatProto3 } from "./private/binary-format-proto3.js";
 import { makeJsonFormatProto3 } from "./private/json-format-proto3.js";

package/dist/esm/service-type.js

@@ -1,3 +1,16 @@
+// Copyright 2021-2022 Buf Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 /**
  * MethodKind represents the four method types that can be declared in
  * protobuf with the `stream` keyword:

package/dist/esm/type-registry.js

@@ -1,3 +1,16 @@
+// Copyright 2021-2022 Buf Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 /**
  * TypeRegistry is a basic type registry
  */

package/dist/types/google/protobuf/any_pb.d.ts

@@ -26,7 +26,7 @@ import { Message } from "../../index.js";
  *       foo = any.unpack(Foo.class);
  *     }
  *
- *  Example 3: Pack and unpack a message in Python.
+ * Example 3: Pack and unpack a message in Python.
  *
  *     foo = Foo(...)
  *     any = Any()
@@ -36,7 +36,7 @@ import { Message } from "../../index.js";
  *       any.Unpack(foo)
  *       ...
  *
- *  Example 4: Pack and unpack a message in Go
+ * Example 4: Pack and unpack a message in Go
  *
  *      foo := &pb.Foo{...}
  *      any, err := anypb.New(foo)
@@ -57,7 +57,7 @@ import { Message } from "../../index.js";
  *
  *
  * JSON
- * ====
+ *
  * The JSON representation of an `Any` value uses the regular
  * representation of the deserialized, embedded message, with an
  * additional field `@type` which contains the type URL. Example:

package/dist/types/google/protobuf/descriptor_pb.d.ts

@@ -286,7 +286,6 @@ export declare class FieldDescriptorProto extends Message<FieldDescriptorProto>
      * For booleans, "true" or "false".
      * For strings, contains the default text contents (not escaped in any way).
      * For bytes, contains the C escaped value.  All bytes >= 128 are escaped.
-     * TODO(kenton):  Base-64 encode?
      *
      * @generated from field: optional string default_value = 7;
      */
@@ -1020,9 +1019,23 @@ export declare class FieldOptions extends Message<FieldOptions> {
      * check its required fields, regardless of whether or not the message has
      * been parsed.
      *
+     * As of 2021, lazy does no correctness checks on the byte stream during
+     * parsing.  This may lead to crashes if and when an invalid byte stream is
+     * finally parsed upon access.
+     *
+     * TODO(b/211906113):  Enable validation on lazy fields.
+     *
      * @generated from field: optional bool lazy = 5 [default = false];
      */
     lazy?: boolean;
+    /**
+     * unverified_lazy does no correctness checks on the byte stream. This should
+     * only be used where lazy with verification is prohibitive for performance
+     * reasons.
+     *
+     * @generated from field: optional bool unverified_lazy = 15 [default = false];
+     */
+    unverifiedLazy?: boolean;
     /**
      * Is this field deprecated?
      * Depending on the target platform, this can emit Deprecated annotations
@@ -1413,8 +1426,8 @@ export declare class SourceCodeInfo_Location extends Message<SourceCodeInfo_Loca
      * location.
      *
      * Each element is a field number or an index.  They form a path from
-     * the root FileDescriptorProto to the place where the definition.  For
-     * example, this path:
+     * the root FileDescriptorProto to the place where the definition occurs.
+     * For example, this path:
      *   [ 4, 3, 2, 7, 1 ]
      * refers to:
      *   file.message_type(3)  // 4, 3

package/dist/types/index.d.ts

@@ -1,7 +1,8 @@
 export { proto3 } from "./proto3.js";
 export { proto2 } from "./proto2.js";
 export { protoInt64 } from "./proto-int64.js";
-export { Message, DynamicMessage, PartialMessage, PlainMessage, } from "./message.js";
+export { protoBase64 } from "./proto-base64.js";
+export { Message, AnyMessage, PartialMessage, PlainMessage, } from "./message.js";
 export type { FieldInfo } from "./field.js";
 export type { FieldList } from "./field-list.js";
 export { ScalarType } from "./field.js";

package/dist/types/json-format.d.ts

@@ -19,7 +19,7 @@ export interface JsonFormat {
     /**
      * Parse a message from JSON.
      */
-    readMessage<T extends Message>(type: MessageType<T>, jsonValue: JsonValue, options: JsonReadOptions, message?: T): T;
+    readMessage<T extends Message<T>>(type: MessageType<T>, jsonValue: JsonValue, options: JsonReadOptions, message?: T): T;
     /**
      * Serialize a message to JSON.
      */

package/dist/types/message-type.d.ts

@@ -2,7 +2,7 @@ import type { FieldList } from "./field-list.js";
 import type { ProtoRuntime } from "./private/proto-runtime.js";
 import type { JsonReadOptions, JsonValue } from "./json-format.js";
 import type { BinaryReadOptions } from "./binary-format.js";
-import type { DynamicMessage, Message, PartialMessage, PlainMessage } from "./message.js";
+import type { AnyMessage, Message, PartialMessage, PlainMessage } from "./message.js";
 import type { FieldWrapper } from "./private/field-wrapper.js";
 /**
  * MessageType represents a protobuf message. It provides:
@@ -10,7 +10,7 @@ import type { FieldWrapper } from "./private/field-wrapper.js";
  * - metadata for reflection-based operations
  * - common functionality like serialization
  */
-export interface MessageType<T extends Message = DynamicMessage> {
+export interface MessageType<T extends Message<T> = AnyMessage> {
     /**
      * Create a new instance of this type.
      */
@@ -45,6 +45,7 @@ export interface MessageType<T extends Message = DynamicMessage> {
     fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): T;
     /**
      * Returns true if the given arguments have equal field values, recursively.
+     * Will also return true if both messages are `undefined` or `null`.
      */
-    equals(a: T | PlainMessage<T> | undefined, b: T | PlainMessage<T> | undefined): boolean;
+    equals(a: T | PlainMessage<T> | undefined | null, b: T | PlainMessage<T> | undefined | null): boolean;
 }

package/dist/types/message.d.ts

@@ -2,17 +2,25 @@ import type { BinaryReadOptions, BinaryWriteOptions } from "./binary-format.js";
 import type { JsonReadOptions, JsonValue, JsonWriteOptions, JsonWriteStringOptions } from "./json-format.js";
 import type { MessageType } from "./message-type.js";
 /**
- * Every message - generated or created at runtime - is an instance of this
- * class.
+ * AnyMessage is an interface implemented by all messages. If you need to
+ * handle messages of unknown type, this interface provides a convenient
+ * index signature to access fields with message["fieldname"].
+ */
+export interface AnyMessage extends Message<AnyMessage> {
+    [k: string]: any;
+}
+/**
+ * Message is the base class of every message, generated, or created at
+ * runtime.
  *
- * It is unsafe to extend this class. If you want to create a message at run
- * time, use proto3.makeMessageType().
+ * It is _not_ safe to extend this class. If you want to create a message at
+ * run time, use proto3.makeMessageType().
  */
-export declare class Message<T extends Message = DynamicMessage> {
+export declare class Message<T extends Message<T> = AnyMessage> {
     /**
      * Compare with a message of the same type.
      */
-    equals(other: T | PlainMessage<T> | undefined): boolean;
+    equals(other: T | PlainMessage<T> | undefined | null): boolean;
     /**
      * Create a deep copy.
      */
@@ -73,13 +81,13 @@ export declare type PlainMessage<T extends Message> = {
 export declare type PartialMessage<T extends Message> = {
     [P in keyof T as T[P] extends Function ? never : P]?: PartialField<T[P]>;
 };
-declare type PartialField<F> = F extends (Date | Uint8Array | bigint | boolean | string | number) ? F : F extends Array<infer U> ? Array<PartialField<U>> : F extends ReadonlyArray<infer U> ? ReadonlyArray<PartialField<U>> : F extends OneofSelectedMessage<infer C, infer V> ? {
+declare type PartialField<F> = F extends (Date | Uint8Array | bigint | boolean | string | number) ? F : F extends Array<infer U> ? Array<PartialField<U>> : F extends ReadonlyArray<infer U> ? ReadonlyArray<PartialField<U>> : F extends Message ? PartialMessage<F> : F extends OneofSelectedMessage<infer C, infer V> ? {
     case: C;
     value: PartialMessage<V>;
 } : F extends {
     case: string | undefined;
     value?: unknown;
-} ? F : F extends Message ? PartialMessage<F> : F extends {
+} ? F : F extends {
     [key: string | number]: Message<infer U>;
 } ? {
     [key: string | number]: PartialMessage<U>;
@@ -88,11 +96,4 @@ declare type OneofSelectedMessage<K extends string, M extends Message> = {
     case: K;
     value: M;
 };
-/**
- * DynamicMessage exposes the fields of the message with an index signature,
- * which means that fields can be accessed with message["fieldname"].
- */
-export declare type DynamicMessage = Message & {
-    [k: string]: any;
-};
 export {};

package/dist/types/private/enum.d.ts

@@ -20,3 +20,12 @@ export declare function setEnumType(enumObject: EnumObject, typeName: string, va
  * Create a new EnumType with the given values.
  */
 export declare function makeEnumType(typeName: string, values: EnumValueInfo[]): EnumType;
+/**
+ * Create a new enum object with the given values.
+ */
+export declare function makeEnum(typeName: string, values: EnumValueInfo[], opt?: {
+    /**
+     * MY_ENUM_ for `enum MyEnum {MY_ENUM_A=0; MY_ENUM_B=1;}`, or blank string
+     */
+    sharedPrefix?: string;
+}): EnumObject;

package/dist/types/private/field-wrapper.d.ts

@@ -7,15 +7,15 @@ import type { MessageType } from "../message-type.js";
  * Note that this feature exists for google/protobuf/{wrappers,struct}.proto
  * and cannot be used to arbitrarily modify types in generated code.
  */
-export interface FieldWrapper<T extends Message = any, U = any> {
+export interface FieldWrapper<T extends Message<T> = any, U = any> {
     wrapField(value: U): T;
     unwrapField(value: T): U;
 }
 /**
  * Wrap field values whose message type has a wrapper.
  */
-export declare function wrapField<T extends Message>(type: MessageType<T>, value: any): T;
+export declare function wrapField<T extends Message<T>>(type: MessageType<T>, value: any): T;
 /**
  * Unwrap field values whose message type has a wrapper.
  */
-export declare function unwrapField<T extends Message>(type: MessageType<T>, value: T): any;
+export declare function unwrapField<T extends Message<T>>(type: MessageType<T>, value: T): any;

package/dist/types/private/message-type.d.ts

@@ -1,10 +1,20 @@
-import { DynamicMessage, Message } from "../message.js";
+import { AnyMessage, Message } from "../message.js";
 import type { FieldListSource } from "./field-list.js";
 import type { MessageType } from "../message-type.js";
 import type { ProtoRuntime } from "./proto-runtime.js";
 /**
  * Create a new message type using the given runtime.
  */
-export declare function makeMessageType<T extends Message = DynamicMessage>(runtime: ProtoRuntime, typeName: string, fields: FieldListSource, opt?: {
+export declare function makeMessageType<T extends Message<T> = AnyMessage>(runtime: ProtoRuntime, typeName: string, fields: FieldListSource, opt?: {
+    /**
+     * localName is the "name" property of the constructed function.
+     * It is useful in stack traces, debuggers and test frameworks,
+     * but has no other implications.
+     *
+     * This property is optional because by default, the last part
+     * from the given typeName is used. Since this does not take
+     * reserved words into account, we provide this property so that
+     * an escaped name can be given.
+     */
     localName?: string;
 }): MessageType<T>;

package/dist/types/private/proto-runtime.d.ts

@@ -1,6 +1,6 @@
-import type { JsonFormat, JsonValue } from "../json-format.js";
+import type { JsonFormat } from "../json-format.js";
 import type { BinaryFormat } from "../binary-format.js";
-import type { DynamicMessage } from "../message.js";
+import type { AnyMessage } from "../message.js";
 import type { Message } from "../message.js";
 import type { EnumType, EnumValueInfo } from "../enum.js";
 import type { MessageType } from "../message-type.js";
@@ -18,24 +18,29 @@ export interface ProtoRuntime {
     /**
      * Create a message type at runtime, without generating code.
      */
-    makeMessageType<T extends Message = DynamicMessage>(typeName: string, fields: FieldListSource, opt?: {
+    makeMessageType<T extends Message<T> = AnyMessage>(typeName: string, fields: FieldListSource, opt?: {
         localName?: string;
-        options?: {
-            readonly [extensionName: string]: JsonValue;
-        };
     }): MessageType<T>;
+    /**
+     * Create an enum object at runtime, without generating code.
+     *
+     * The object conforms to TypeScript enums, and comes with
+     * mapping from name to value, and from value to name.
+     *
+     * The type name and other reflection information is accessible
+     * via getEnumType().
+     */
+    makeEnum(typeName: string, values: EnumValueInfo[], opt?: {}): EnumObject;
     /**
      * Create an enum type at runtime, without generating code.
+     * Note that this only creates the reflection information, not an
+     * actual enum object.
      */
-    makeEnumType(typeName: string, values: EnumValueInfo[], opt?: {
-        options?: {
-            readonly [extensionName: string]: JsonValue;
-        };
-    }): EnumType;
+    makeEnumType(typeName: string, values: EnumValueInfo[], opt?: {}): EnumType;
     /**
-     * Get reflection information from a generated enum.
+     * Get reflection information - the EnumType - from an enum object.
      * If this function is called on something other than a generated
-     * enum, it raises an error.
+     * enum, or an enum constructed with makeEnum(), it raises an error.
      */
     getEnumType(enumObject: EnumObject): EnumType;
 }

package/dist/types/private/util.d.ts

@@ -30,14 +30,14 @@ export interface Util {
     /**
      * Set specified field values on the target message, recursively.
      */
-    initPartial<T extends Message>(source: PartialMessage<T> | undefined, target: T): void;
+    initPartial<T extends Message<T>>(source: PartialMessage<T> | undefined, target: T): void;
     /**
      * Compares two messages of the same type recursively.
-     * Will also return true if both messages are `undefined`.
+     * Will also return true if both messages are `undefined` or `null`.
      */
-    equals<T extends Message>(type: MessageType, a: T | PlainMessage<T> | undefined, b: T | PlainMessage<T> | undefined): boolean;
+    equals<T extends Message<T>>(type: MessageType, a: T | PlainMessage<T> | undefined | null, b: T | PlainMessage<T> | undefined | null): boolean;
     /**
      * Create a deep copy.
      */
-    clone<T extends Message>(message: T): T;
+    clone<T extends Message<T>>(message: T): T;
 }

package/dist/types/proto-base64.d.ts

@@ -0,0 +1,26 @@
+export declare const protoBase64: {
+    /**
+     * Decodes a base64 string to a byte array.
+     *
+     * - ignores white-space, including line breaks and tabs
+     * - allows inner padding (can decode concatenated base64 strings)
+     * - does not require padding
+     * - understands base64url encoding:
+     *   "-" instead of "+",
+     *   "_" instead of "/",
+     *   no padding
+     */
+    readonly dec: (base64Str: string) => Uint8Array;
+    /**
+     * Decodes a base64 string to a byte array.
+     *
+     * - ignores white-space, including line breaks and tabs
+     * - allows inner padding (can decode concatenated base64 strings)
+     * - does not require padding
+     * - understands base64url encoding:
+     *   "-" instead of "+",
+     *   "_" instead of "/",
+     *   no padding
+     */
+    readonly enc: (bytes: Uint8Array) => string;
+};

package/dist/types/service-type.d.ts

@@ -1,4 +1,4 @@
-import type { DynamicMessage, Message } from "./message.js";
+import type { AnyMessage, Message } from "./message.js";
 import type { MessageType } from "./message-type.js";
 /**
  * ServiceType represents a protobuf services. It provides metadata for
@@ -29,32 +29,32 @@ export interface ServiceType {
  * - "idempotency": User-provided indication whether the method will cause
  *   the same effect every time it is called.
  */
-export declare type MethodInfo<I extends Message = DynamicMessage, O extends Message = DynamicMessage> = MethodInfoUnary<I, O> | MethodInfoServerStreaming<I, O> | MethodInfoClientStreaming<I, O> | MethodInfoBiDiStreaming<I, O>;
+export declare type MethodInfo<I extends Message<I> = AnyMessage, O extends Message<O> = AnyMessage> = MethodInfoUnary<I, O> | MethodInfoServerStreaming<I, O> | MethodInfoClientStreaming<I, O> | MethodInfoBiDiStreaming<I, O>;
 /**
  * A unary method: rpc (Input) returns (Output)
  */
-export interface MethodInfoUnary<I extends Message, O extends Message> extends miShared<I, O> {
+export interface MethodInfoUnary<I extends Message<I>, O extends Message<O>> extends miShared<I, O> {
     readonly kind: MethodKind.Unary;
 }
 /**
  * A server streaming method: rpc (Input) returns (stream Output)
  */
-export interface MethodInfoServerStreaming<I extends Message, O extends Message> extends miShared<I, O> {
+export interface MethodInfoServerStreaming<I extends Message<I>, O extends Message<O>> extends miShared<I, O> {
     readonly kind: MethodKind.ServerStreaming;
 }
 /**
  * A client streaming method: rpc (stream Input) returns (Output)
  */
-export interface MethodInfoClientStreaming<I extends Message, O extends Message> extends miShared<I, O> {
+export interface MethodInfoClientStreaming<I extends Message<I>, O extends Message<O>> extends miShared<I, O> {
     readonly kind: MethodKind.ClientStreaming;
 }
 /**
  * A method that streams bi-directionally: rpc (stream Input) returns (stream Output)
  */
-export interface MethodInfoBiDiStreaming<I extends Message, O extends Message> extends miShared<I, O> {
+export interface MethodInfoBiDiStreaming<I extends Message<I>, O extends Message<O>> extends miShared<I, O> {
     readonly kind: MethodKind.BiDiStreaming;
 }
-interface miShared<I extends Message = DynamicMessage, O extends Message = DynamicMessage> {
+interface miShared<I extends Message<I> = AnyMessage, O extends Message<O> = AnyMessage> {
     readonly name: string;
     readonly I: MessageType<I>;
     readonly O: MessageType<O>;

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@bufbuild/protobuf",
-  "version": "0.0.1",
+  "version": "0.0.2-alpha.3",
   "license": "(Apache-2.0 AND BSD-3-Clause)",
   "description": "A complete implementation of protocol buffers in TypeScript, suitable for web browsers and Node.js.",
   "repository": {
     "type": "git",
-    "url": "https://github.com/bufbuild/connect-web.git",
+    "url": "https://github.com/bufbuild/protobuf-es.git",
     "directory": "packages/protobuf"
   },
   "scripts": {
@@ -15,7 +15,6 @@
     "build:esm+types": "npx tsc --project tsconfig.json --module ES2015 --outDir ./dist/esm --declaration --declarationDir ./dist/types"
   },
   "type": "module",
-  "main": "./dist/cjs/index.js",
   "types": "./dist/types/index.d.ts",
   "exports": {
     "import": "./dist/esm/index.js",
@@ -23,7 +22,7 @@
     "default": "./dist/esm/index.js"
   },
   "devDependencies": {
-    "typescript": "^4.5.4"
+    "typescript": "^4.6.3"
   },
   "files": [
     "dist/**/"