@apibara/protocol 2.1.0-beta.5 → 2.1.0-beta.50

package/dist/codec.mjs

@@ -0,0 +1,224 @@
+function MessageCodec(schema) {
+  return {
+    encode(app) {
+      return new Proxy(app, {
+        get(target, property) {
+          if (!Object.hasOwn(target, property)) {
+            return Reflect.get(target, property);
+          }
+          const v = Reflect.get(target, property);
+          return schema[property].encode(v);
+        }
+      });
+    },
+    decode(proto) {
+      return new Proxy(proto, {
+        get(target, property) {
+          if (!Object.hasOwn(target, property)) {
+            return Reflect.get(target, property);
+          }
+          const v = Reflect.get(target, property);
+          return schema[property].decode(v);
+        }
+      });
+    }
+  };
+}
+function ArrayCodec(t) {
+  return {
+    encode(app) {
+      return app.map(t.encode);
+    },
+    decode(proto) {
+      if (proto === void 0)
+        return [];
+      return proto.map(t.decode);
+    }
+  };
+}
+function MutableArrayCodec(t) {
+  return {
+    encode(app) {
+      return app.map(t.encode);
+    },
+    decode(proto) {
+      if (proto === void 0)
+        return [];
+      return proto.map(t.decode);
+    }
+  };
+}
+function OptionalCodec(t) {
+  return {
+    encode(app) {
+      if (app === void 0)
+        return void 0;
+      return t.encode(app);
+    },
+    decode(proto) {
+      if (proto === void 0)
+        return void 0;
+      return t.decode(proto);
+    }
+  };
+}
+function RequiredCodec(t) {
+  return {
+    encode(app) {
+      if (app === void 0)
+        throw new Error("Value is required but undefined");
+      return t.encode(app);
+    },
+    decode(proto) {
+      if (proto === void 0)
+        throw new Error("Value is required but undefined");
+      return t.decode(proto);
+    }
+  };
+}
+function NullOrCodec(t) {
+  return {
+    encode(app) {
+      if (app === null)
+        return null;
+      return t.encode(app);
+    },
+    decode(proto) {
+      if (proto === null)
+        return null;
+      return t.decode(proto);
+    }
+  };
+}
+const BigIntCodec = {
+  encode(app) {
+    return app;
+  },
+  decode(proto) {
+    return proto;
+  }
+};
+const NumberCodec = {
+  encode(app) {
+    return app;
+  },
+  decode(proto) {
+    return proto;
+  }
+};
+const Uint8ArrayCodec = {
+  encode(app) {
+    return app;
+  },
+  decode(proto) {
+    return proto;
+  }
+};
+const DateCodec = {
+  encode(app) {
+    return new Date(app);
+  },
+  decode(proto) {
+    return new Date(proto);
+  }
+};
+const BooleanCodec = {
+  encode(app) {
+    return app;
+  },
+  decode(proto) {
+    return proto;
+  }
+};
+const StringCodec = {
+  encode(app) {
+    return app;
+  },
+  decode(proto) {
+    return proto;
+  }
+};
+const UndefinedCodec = {
+  encode(app) {
+    return void 0;
+  },
+  decode(proto) {
+    return void 0;
+  }
+};
+const LiteralCodec = (value) => {
+  return {
+    encode(app) {
+      if (app !== value) {
+        throw new Error(`Expected ${String(value)}, got ${String(app)}`);
+      }
+      return app;
+    },
+    decode(proto) {
+      if (proto !== value) {
+        throw new Error(`Expected ${String(value)}, got ${String(proto)}`);
+      }
+      return proto;
+    }
+  };
+};
+const LiteralUnionCodec = (values) => {
+  return {
+    encode(app) {
+      if (!values.includes(app)) {
+        throw new Error(
+          `Expected one of [${values.join(", ")}], got ${String(app)}`
+        );
+      }
+      return app;
+    },
+    decode(proto) {
+      if (!values.includes(proto)) {
+        throw new Error(
+          `Expected one of [${values.join(", ")}], got ${String(proto)}`
+        );
+      }
+      return proto;
+    }
+  };
+};
+const VariantCodec = (options) => {
+  return {
+    encode(app) {
+      const tag = app[options.tag];
+      const codec = options.variants[tag];
+      if (!codec) {
+        throw new Error(`Unknown variant: ${String(tag)}`);
+      }
+      const variantData = app[tag];
+      const encodedData = codec.encode(variantData);
+      return {
+        [options.discriminator]: tag,
+        [tag]: encodedData
+      };
+    },
+    decode(proto) {
+      const tag = proto[options.discriminator];
+      const codec = options.variants[tag];
+      if (!codec) {
+        throw new Error(`Unknown variant: ${String(tag)}`);
+      }
+      const variantData = proto[tag];
+      const decodedData = codec.decode(variantData);
+      return {
+        [options.tag]: tag,
+        [tag]: decodedData
+      };
+    }
+  };
+};
+function OneOfCodec(variants) {
+  return VariantCodec({
+    tag: "_tag",
+    discriminator: "$case",
+    variants
+  });
+}
+
+export { ArrayCodec, BigIntCodec, BooleanCodec, DateCodec, LiteralCodec, LiteralUnionCodec, MessageCodec, MutableArrayCodec, NullOrCodec, NumberCodec, OneOfCodec, OptionalCodec, RequiredCodec, StringCodec, Uint8ArrayCodec, UndefinedCodec, VariantCodec };
+//# sourceMappingURL=codec.mjs.map

package/dist/codec.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec.mjs","sources":["../src/codec.ts"],"sourcesContent":["/*\n\n   █████████               █████                  \n  ███░░░░░███             ░░███                   \n ███     ░░░   ██████   ███████   ██████   ██████ \n░███          ███░░███ ███░░███  ███░░███ ███░░███\n░███         ░███ ░███░███ ░███ ░███████ ░███ ░░░ \n░░███     ███░███ ░███░███ ░███ ░███░░░  ░███  ███\n ░░█████████ ░░██████ ░░████████░░██████ ░░██████ \n  ░░░░░░░░░   ░░░░░░   ░░░░░░░░  ░░░░░░   ░░░░░░  \n                                                  \n*/\n\n/** Codec to encode and decode protobuf messages */\nexport type Codec<TApp = unknown, TProto = unknown> = {\n  encode(app: TApp): TProto;\n  decode(proto: TProto): TApp;\n};\n\n/* Helper to get the high-level type of a codec */\nexport type CodecType<C extends Codec> = ReturnType<C[\"decode\"]>;\n\n/* Helper to get the protobuf type of a codec */\nexport type CodecProto<C extends Codec> = ReturnType<C[\"encode\"]>;\n\n/*\n \n ██████   ██████                                                     \n░░██████ ██████                                                      \n ░███░█████░███   ██████   █████   █████   ██████    ███████  ██████ \n ░███░░███ ░███  ███░░███ ███░░   ███░░   ░░░░░███  ███░░███ ███░░███\n ░███ ░░░  ░███ ░███████ ░░█████ ░░█████   ███████ ░███ ░███░███████ \n ░███      ░███ ░███░░░   ░░░░███ ░░░░███ ███░░███ ░███ ░███░███░░░  \n █████     █████░░██████  ██████  ██████ ░░████████░░███████░░██████ \n░░░░░     ░░░░░  ░░░░░░  ░░░░░░  ░░░░░░   ░░░░░░░░  ░░░░░███ ░░░░░░  \n                                                    ███ ░███         \n                                                   ░░██████          \n                                                    ░░░░░░                                                                             \n*/\n\nexport type Evaluate<T> = T extends infer O ? { [K in keyof O]: O[K] } : never;\n\ntype TPropertyKey = string | symbol;\n// Message properties as codec.\ntype TProperties = Record<TPropertyKey, Codec>;\n\n// Optional properties in an object.\n// Properties are optional when they have the `undefined` type.\ntype OptionalPropertyKeys<T> = {\n  [K in keyof T]: undefined extends T[K] ? K : never;\n}[keyof T];\n\n// Properties that are not optional are required.\ntype RequiredPropertyKeys<T> = keyof Omit<T, OptionalPropertyKeys<T>>;\n\n// Helper to get the app type of a message codec.\ntype _MessageCodecType<T extends TProperties> = {\n  [K in keyof T]: CodecType<T[K]>;\n};\n\n// Helper to get the protobuf type of a message codec.\ntype _MessageCodecProto<T extends TProperties> = {\n  [K in keyof T]: CodecProto<T[K]>;\n};\n\n// Adjust the app type of the codec so that optional properties are optional.\ntype MessageCodecType<T extends TProperties> =\n  _MessageCodecType<T> extends infer R\n    ? Evaluate<Partial<R> & Required<Pick<R, RequiredPropertyKeys<R>>>>\n    : never;\n\n// Adjust the protobuf type of the codec so that optional properties are optional.\ntype MessageCodecProto<T extends TProperties> =\n  _MessageCodecProto<T> extends infer R\n    ? Evaluate<Partial<R> & Required<Pick<R, RequiredPropertyKeys<R>>>>\n    : never;\n\nexport type MessageCodec<T extends TProperties = TProperties> = Codec<\n  MessageCodecType<T>,\n  MessageCodecProto<T>\n>;\n\nexport function MessageCodec<T extends TProperties>(\n  schema: T,\n): MessageCodec<T> {\n  return {\n    encode(app) {\n      return new Proxy(app, {\n        get(target, property) {\n          if (!Object.hasOwn(target, property)) {\n            return Reflect.get(target, property);\n          }\n\n          const v = Reflect.get(target, property);\n          return schema[property].encode(v);\n        },\n      });\n    },\n    decode(proto) {\n      return new Proxy(proto, {\n        get(target, property) {\n          if (!Object.hasOwn(target, property)) {\n            return Reflect.get(target, property);\n          }\n\n          const v = Reflect.get(target, property);\n          return schema[property].decode(v);\n        },\n      });\n    },\n  };\n}\n\n/*\n   █████████                                           \n  ███░░░░░███                                          \n ░███    ░███  ████████  ████████   ██████   █████ ████\n ░███████████ ░░███░░███░░███░░███ ░░░░░███ ░░███ ░███ \n ░███░░░░░███  ░███ ░░░  ░███ ░░░   ███████  ░███ ░███ \n ░███    ░███  ░███      ░███      ███░░███  ░███ ░███ \n █████   █████ █████     █████    ░░████████ ░░███████ \n░░░░░   ░░░░░ ░░░░░     ░░░░░      ░░░░░░░░   ░░░░░███ \n                                              ███ ░███ \n                                             ░░██████  \n                                              ░░░░░░   \n                                                                    \n*/\n\nexport type ArrayCodec<T extends Codec> = T extends Codec<\n  infer TApp,\n  infer TProto\n>\n  ? Codec<readonly TApp[], readonly TProto[] | undefined>\n  : never;\n\nexport function ArrayCodec<T extends Codec<TApp, TProto>, TApp, TProto>(\n  t: T,\n): ArrayCodec<T> {\n  return {\n    encode(app) {\n      return app.map(t.encode) as readonly TProto[];\n    },\n    decode(proto) {\n      if (proto === undefined) return [];\n      return proto.map(t.decode) as readonly TApp[];\n    },\n  } as ArrayCodec<T>;\n}\n\n/*\n ██████   ██████             █████              █████     ████             █████████               █████                  \n░░██████ ██████             ░░███              ░░███     ░░███            ███░░░░░███             ░░███                   \n ░███░█████░███  █████ ████ ███████    ██████   ░███████  ░███   ██████  ███     ░░░   ██████   ███████   ██████   ██████ \n ░███░░███ ░███ ░░███ ░███ ░░░███░    ░░░░░███  ░███░░███ ░███  ███░░███░███          ███░░███ ███░░███  ███░░███ ███░░███\n ░███ ░░░  ░███  ░███ ░███   ░███      ███████  ░███ ░███ ░███ ░███████ ░███         ░███ ░███░███ ░███ ░███████ ░███ ░░░ \n ░███      ░███  ░███ ░███   ░███ ███ ███░░███  ░███ ░███ ░███ ░███░░░  ░░███     ███░███ ░███░███ ░███ ░███░░░  ░███  ███\n █████     █████ ░░████████  ░░█████ ░░████████ ████████  █████░░██████  ░░█████████ ░░██████ ░░████████░░██████ ░░██████ \n░░░░░     ░░░░░   ░░░░░░░░    ░░░░░   ░░░░░░░░ ░░░░░░░░  ░░░░░  ░░░░░░    ░░░░░░░░░   ░░░░░░   ░░░░░░░░  ░░░░░░   ░░░░░░  \n*/\nexport type MutableArrayCodec<\n  T extends Codec<TApp, TProto>,\n  TApp,\n  TProto,\n> = T extends Codec<infer TApp, infer TProto> ? Codec<TApp[], TProto[]> : never;\n\nexport function MutableArrayCodec<T extends Codec<TApp, TProto>, TApp, TProto>(\n  t: T,\n): MutableArrayCodec<T, TApp, TProto> {\n  return {\n    encode(app) {\n      return app.map(t.encode) as TProto[];\n    },\n    decode(proto) {\n      if (proto === undefined) return [];\n      return proto.map(t.decode) as TApp[];\n    },\n  } as MutableArrayCodec<T, TApp, TProto>;\n}\n\n/*\n    ███████               █████     ███                                ████ \n  ███░░░░░███            ░░███     ░░░                                ░░███ \n ███     ░░███ ████████  ███████   ████   ██████  ████████    ██████   ░███ \n░███      ░███░░███░░███░░░███░   ░░███  ███░░███░░███░░███  ░░░░░███  ░███ \n░███      ░███ ░███ ░███  ░███     ░███ ░███ ░███ ░███ ░███   ███████  ░███ \n░░███     ███  ░███ ░███  ░███ ███ ░███ ░███ ░███ ░███ ░███  ███░░███  ░███ \n ░░░███████░   ░███████   ░░█████  █████░░██████  ████ █████░░████████ █████\n   ░░░░░░░     ░███░░░     ░░░░░  ░░░░░  ░░░░░░  ░░░░ ░░░░░  ░░░░░░░░ ░░░░░ \n               ░███                                                         \n               █████                                                        \n              ░░░░░                                                                                                                                                  \n*/\n\nexport type OptionalCodec<T extends Codec> = T extends Codec<\n  infer TApp,\n  infer TProto\n>\n  ? Codec<TApp | undefined, TProto | undefined>\n  : never;\n\nexport function OptionalCodec<T extends Codec>(t: T): OptionalCodec<T> {\n  return {\n    encode(app) {\n      if (app === undefined) return undefined;\n      return t.encode(app);\n    },\n    decode(proto) {\n      if (proto === undefined) return undefined;\n      return t.decode(proto);\n    },\n  } as OptionalCodec<T>;\n}\n\n/*\n ███████████                                  ███                         █████\n░░███░░░░░███                                ░░░                         ░░███ \n ░███    ░███   ██████   ████████ █████ ████ ████  ████████   ██████   ███████ \n ░██████████   ███░░███ ███░░███ ░░███ ░███ ░░███ ░░███░░███ ███░░███ ███░░███ \n ░███░░░░░███ ░███████ ░███ ░███  ░███ ░███  ░███  ░███ ░░░ ░███████ ░███ ░███ \n ░███    ░███ ░███░░░  ░███ ░███  ░███ ░███  ░███  ░███     ░███░░░  ░███ ░███ \n █████   █████░░██████ ░░███████  ░░████████ █████ █████    ░░██████ ░░████████\n░░░░░   ░░░░░  ░░░░░░   ░░░░░███   ░░░░░░░░ ░░░░░ ░░░░░      ░░░░░░   ░░░░░░░░ \n                            ░███                                               \n                            █████                                              \n                           ░░░░░                                                                                                                                                           \n*/\n\nexport type RequiredCodec<T extends Codec> = T extends Codec<\n  infer TApp,\n  infer TProto\n>\n  ? TApp extends undefined\n    ? never\n    : Codec<TApp, TProto | undefined>\n  : never;\n\nexport function RequiredCodec<T extends Codec>(t: T): RequiredCodec<T> {\n  return {\n    encode(app) {\n      if (app === undefined) throw new Error(\"Value is required but undefined\");\n      return t.encode(app);\n    },\n    decode(proto) {\n      if (proto === undefined)\n        throw new Error(\"Value is required but undefined\");\n      return t.decode(proto);\n    },\n  } as RequiredCodec<T>;\n}\n\n/*\n ██████   █████            ████  ████     ███████             \n░░██████ ░░███            ░░███ ░░███   ███░░░░░███           \n ░███░███ ░███  █████ ████ ░███  ░███  ███     ░░███ ████████ \n ░███░░███░███ ░░███ ░███  ░███  ░███ ░███      ░███░░███░░███\n ░███ ░░██████  ░███ ░███  ░███  ░███ ░███      ░███ ░███ ░░░ \n ░███  ░░█████  ░███ ░███  ░███  ░███ ░░███     ███  ░███     \n █████  ░░█████ ░░████████ █████ █████ ░░░███████░   █████    \n░░░░░    ░░░░░   ░░░░░░░░ ░░░░░ ░░░░░    ░░░░░░░    ░░░░░     \n*/\n\nexport type NullOrCodec<T extends Codec> = T extends Codec<\n  infer TApp,\n  infer TProto\n>\n  ? Codec<TApp | null, TProto | null>\n  : never;\n\nexport function NullOrCodec<T extends Codec>(t: T): NullOrCodec<T> {\n  return {\n    encode(app) {\n      if (app === null) return null;\n      return t.encode(app);\n    },\n    decode(proto) {\n      if (proto === null) return null;\n      return t.decode(proto);\n    },\n  } as NullOrCodec<T>;\n}\n\n/*\n\n ███████████   ███           █████             █████   \n░░███░░░░░███ ░░░           ░░███             ░░███    \n ░███    ░███ ████   ███████ ░███  ████████   ███████  \n ░██████████ ░░███  ███░░███ ░███ ░░███░░███ ░░░███░   \n ░███░░░░░███ ░███ ░███ ░███ ░███  ░███ ░███   ░███    \n ░███    ░███ ░███ ░███ ░███ ░███  ░███ ░███   ░███ ███\n ███████████  █████░░███████ █████ ████ █████  ░░█████ \n░░░░░░░░░░░  ░░░░░  ░░░░░███░░░░░ ░░░░ ░░░░░    ░░░░░  \n                    ███ ░███                           \n                   ░░██████                            \n                    ░░░░░░                                                                             \n*/\n\nexport type BigIntCodec = CodecType<typeof BigIntCodec>;\n\nexport const BigIntCodec: Codec<bigint, bigint> = {\n  encode(app) {\n    return app;\n  },\n  decode(proto) {\n    return proto;\n  },\n};\n\n/*\n\n ██████   █████                            █████                       \n░░██████ ░░███                            ░░███                        \n ░███░███ ░███  █████ ████ █████████████   ░███████   ██████  ████████ \n ░███░░███░███ ░░███ ░███ ░░███░░███░░███  ░███░░███ ███░░███░░███░░███\n ░███ ░░██████  ░███ ░███  ░███ ░███ ░███  ░███ ░███░███████  ░███ ░░░ \n ░███  ░░█████  ░███ ░███  ░███ ░███ ░███  ░███ ░███░███░░░   ░███     \n █████  ░░█████ ░░████████ █████░███ █████ ████████ ░░██████  █████    \n░░░░░    ░░░░░   ░░░░░░░░ ░░░░░ ░░░ ░░░░░ ░░░░░░░░   ░░░░░░  ░░░░░     \n                                                                                  \n*/\n\nexport type NumberCodec = CodecType<typeof NumberCodec>;\n\nexport const NumberCodec: Codec<number, number> = {\n  encode(app) {\n    return app;\n  },\n  decode(proto) {\n    return proto;\n  },\n};\n\n/*\n █████  █████  ███              █████     ████████     █████████                                           \n░░███  ░░███  ░░░              ░░███     ███░░░░███   ███░░░░░███                                          \n ░███   ░███  ████  ████████   ███████  ░███   ░███  ░███    ░███  ████████  ████████   ██████   █████ ████\n ░███   ░███ ░░███ ░░███░░███ ░░░███░   ░░████████   ░███████████ ░░███░░███░░███░░███ ░░░░░███ ░░███ ░███ \n ░███   ░███  ░███  ░███ ░███   ░███     ███░░░░███  ░███░░░░░███  ░███ ░░░  ░███ ░░░   ███████  ░███ ░███ \n ░███   ░███  ░███  ░███ ░███   ░███ ███░███   ░███  ░███    ░███  ░███      ░███      ███░░███  ░███ ░███ \n ░░████████   █████ ████ █████  ░░█████ ░░████████   █████   █████ █████     █████    ░░████████ ░░███████ \n  ░░░░░░░░   ░░░░░ ░░░░ ░░░░░    ░░░░░   ░░░░░░░░   ░░░░░   ░░░░░ ░░░░░     ░░░░░      ░░░░░░░░   ░░░░░███ \n                                                                                                  ███ ░███ \n                                                                                                 ░░██████  \n                                                                                                  ░░░░░░   \n*/\n\nexport type Uint8ArrayCodec = CodecType<typeof Uint8ArrayCodec>;\n\nexport const Uint8ArrayCodec: Codec<Uint8Array, Uint8Array> = {\n  encode(app) {\n    return app;\n  },\n  decode(proto) {\n    return proto;\n  },\n};\n\n/*\n\n ██████████              █████            \n░░███░░░░███            ░░███             \n ░███   ░░███  ██████   ███████    ██████ \n ░███    ░███ ░░░░░███ ░░░███░    ███░░███\n ░███    ░███  ███████   ░███    ░███████ \n ░███    ███  ███░░███   ░███ ███░███░░░  \n ██████████  ░░████████  ░░█████ ░░██████ \n░░░░░░░░░░    ░░░░░░░░    ░░░░░   ░░░░░░  \n                                          \n*/\n\nexport type DateCodec = CodecType<typeof DateCodec>;\n\nexport const DateCodec: Codec<Date, Date> = {\n  encode(app) {\n    return new Date(app);\n  },\n  decode(proto) {\n    return new Date(proto);\n  },\n};\n\n/*\n\n ███████████                    ████                               \n░░███░░░░░███                  ░░███                               \n ░███    ░███  ██████   ██████  ░███   ██████   ██████   ████████  \n ░██████████  ███░░███ ███░░███ ░███  ███░░███ ░░░░░███ ░░███░░███ \n ░███░░░░░███░███ ░███░███ ░███ ░███ ░███████   ███████  ░███ ░███ \n ░███    ░███░███ ░███░███ ░███ ░███ ░███░░░   ███░░███  ░███ ░███ \n ███████████ ░░██████ ░░██████  █████░░██████ ░░████████ ████ █████\n░░░░░░░░░░░   ░░░░░░   ░░░░░░  ░░░░░  ░░░░░░   ░░░░░░░░ ░░░░ ░░░░░ \n                                          \n*/\n\nexport type BooleanCodec = CodecType<typeof BooleanCodec>;\n\nexport const BooleanCodec: Codec<boolean, boolean> = {\n  encode(app) {\n    return app;\n  },\n  decode(proto) {\n    return proto;\n  },\n};\n\n/*\n\n  █████████   █████               ███                     \n ███░░░░░███ ░░███               ░░░                      \n░███    ░░░  ███████   ████████  ████  ████████    ███████\n░░█████████ ░░░███░   ░░███░░███░░███ ░░███░░███  ███░░███\n ░░░░░░░░███  ░███     ░███ ░░░  ░███  ░███ ░███ ░███ ░███\n ███    ░███  ░███ ███ ░███      ░███  ░███ ░███ ░███ ░███\n░░█████████   ░░█████  █████     █████ ████ █████░░███████\n ░░░░░░░░░     ░░░░░  ░░░░░     ░░░░░ ░░░░ ░░░░░  ░░░░░███\n                                                  ███ ░███\n                                                 ░░██████ \n                                                  ░░░░░░  \n*/\n\nexport type StringCodec = CodecType<typeof StringCodec>;\n\nexport const StringCodec: Codec<string, string> = {\n  encode(app) {\n    return app;\n  },\n  decode(proto) {\n    return proto;\n  },\n};\n\n/*\n\n █████  █████                █████             ██████   ███                          █████\n░░███  ░░███                ░░███             ███░░███ ░░░                          ░░███ \n ░███   ░███  ████████    ███████   ██████   ░███ ░░░  ████  ████████    ██████   ███████ \n ░███   ░███ ░░███░░███  ███░░███  ███░░███ ███████   ░░███ ░░███░░███  ███░░███ ███░░███ \n ░███   ░███  ░███ ░███ ░███ ░███ ░███████ ░░░███░     ░███  ░███ ░███ ░███████ ░███ ░███ \n ░███   ░███  ░███ ░███ ░███ ░███ ░███░░░    ░███      ░███  ░███ ░███ ░███░░░  ░███ ░███ \n ░░████████   ████ █████░░████████░░██████   █████     █████ ████ █████░░██████ ░░████████\n  ░░░░░░░░   ░░░░ ░░░░░  ░░░░░░░░  ░░░░░░   ░░░░░     ░░░░░ ░░░░ ░░░░░  ░░░░░░   ░░░░░░░░ \n                                          \n*/\n\nexport type UndefinedCodec = CodecType<typeof UndefinedCodec>;\n\nexport const UndefinedCodec: Codec<undefined, undefined> = {\n  encode(app) {\n    return undefined;\n  },\n  decode(proto) {\n    return undefined;\n  },\n};\n\n/*\n █████        ███   █████                                 ████ \n░░███        ░░░   ░░███                                 ░░███ \n ░███        ████  ███████    ██████  ████████   ██████   ░███ \n ░███       ░░███ ░░░███░    ███░░███░░███░░███ ░░░░░███  ░███ \n ░███        ░███   ░███    ░███████  ░███ ░░░   ███████  ░███ \n ░███      █ ░███   ░███ ███░███░░░   ░███      ███░░███  ░███ \n ███████████ █████  ░░█████ ░░██████  █████    ░░████████ █████\n░░░░░░░░░░░ ░░░░░    ░░░░░   ░░░░░░  ░░░░░      ░░░░░░░░ ░░░░░ \n                                                               \n*/\n\ntype Literal = string | number | boolean | null | undefined;\n\nexport type LiteralCodec<T extends Codec, L extends Literal> = T extends Codec<\n  infer TApp,\n  infer TProto\n>\n  ? Codec<TApp, TProto>\n  : never;\n\nexport const LiteralCodec = <const L extends Literal>(\n  value: L,\n): LiteralCodec<Codec<L, L>, L> => {\n  return {\n    encode(app) {\n      if (app !== value) {\n        throw new Error(`Expected ${String(value)}, got ${String(app)}`);\n      }\n      return app;\n    },\n    decode(proto) {\n      if (proto !== value) {\n        throw new Error(`Expected ${String(value)}, got ${String(proto)}`);\n      }\n      return proto;\n    },\n  } as LiteralCodec<Codec<L, L>, L>;\n};\n\n/*\n █████        ███   █████                                 ████  █████  █████             ███                     \n░░███        ░░░   ░░███                                 ░░███ ░░███  ░░███             ░░░                      \n ░███        ████  ███████    ██████  ████████   ██████   ░███  ░███   ░███  ████████   ████   ██████  ████████  \n ░███       ░░███ ░░░███░    ███░░███░░███░░███ ░░░░░███  ░███  ░███   ░███ ░░███░░███ ░░███  ███░░███░░███░░███ \n ░███        ░███   ░███    ░███████  ░███ ░░░   ███████  ░███  ░███   ░███  ░███ ░███  ░███ ░███ ░███ ░███ ░███ \n ░███      █ ░███   ░███ ███░███░░░   ░███      ███░░███  ░███  ░███   ░███  ░███ ░███  ░███ ░███ ░███ ░███ ░███ \n ███████████ █████  ░░█████ ░░██████  █████    ░░████████ █████ ░░████████   ████ █████ █████░░██████  ████ █████\n░░░░░░░░░░░ ░░░░░    ░░░░░   ░░░░░░  ░░░░░      ░░░░░░░░ ░░░░░   ░░░░░░░░   ░░░░ ░░░░░ ░░░░░  ░░░░░░  ░░░░ ░░░░░ \n*/\n\nexport type LiteralUnionCodec<\n  T extends Codec,\n  L extends readonly Literal[],\n> = T extends Codec<infer TApp, infer TProto> ? Codec<TApp, TProto> : never;\n\nexport const LiteralUnionCodec = <const L extends readonly Literal[]>(\n  values: L,\n): LiteralUnionCodec<Codec<L[number], L[number]>, L> => {\n  return {\n    encode(app) {\n      if (!values.includes(app as L[number])) {\n        throw new Error(\n          `Expected one of [${values.join(\", \")}], got ${String(app)}`,\n        );\n      }\n      return app;\n    },\n    decode(proto) {\n      if (!values.includes(proto as L[number])) {\n        throw new Error(\n          `Expected one of [${values.join(\", \")}], got ${String(proto)}`,\n        );\n      }\n      return proto;\n    },\n  } as LiteralUnionCodec<Codec<L[number], L[number]>, L>;\n};\n\n/*\n █████   █████                      ███                        █████   \n░░███   ░░███                      ░░░                        ░░███    \n ░███    ░███   ██████   ████████  ████   ██████   ████████   ███████  \n ░███    ░███  ░░░░░███ ░░███░░███░░███  ░░░░░███ ░░███░░███ ░░░███░   \n ░░███   ███    ███████  ░███ ░░░  ░███   ███████  ░███ ░███   ░███    \n  ░░░█████░    ███░░███  ░███      ░███  ███░░███  ░███ ░███   ░███ ███\n    ░░███     ░░████████ █████     █████░░████████ ████ █████  ░░█████ \n     ░░░       ░░░░░░░░ ░░░░░     ░░░░░  ░░░░░░░░ ░░░░ ░░░░░    ░░░░░  \n*/\n\n// Maps variant keys to their corresponding decoded types, adding a tag field\n// For example: { _tag: \"declareV1\", declareV1: { data: string } }\n// if the variant is undefined type, it will be just the tag - { _tag: \"heartbeat\" }\ntype AppVariantMap<TTag extends TPropertyKey, TVariants extends TProperties> = {\n  [K in keyof TVariants]: {\n    [P in TTag]: K;\n  } & (CodecType<TVariants[K]> extends UndefinedCodec\n    ? // biome-ignore lint/complexity/noBannedTypes: had to return empty object to satisfy type\n      {}\n    : { [P in K & TPropertyKey]: CodecType<TVariants[K]> });\n};\ntype VariantCodecType<\n  TTag extends TPropertyKey,\n  TVariants extends TProperties,\n> = AppVariantMap<TTag, TVariants>[keyof TVariants];\n\n// Maps variant keys to their corresponding encoded types, adding a discriminator field\n// For example: { $case: \"declareV1\", declareV1: { data: string } }\ntype ProtoVariantMap<\n  TDiscriminator extends TPropertyKey,\n  TVariants extends TProperties,\n> = {\n  [K in keyof TVariants]: {\n    [P in TDiscriminator]: K;\n  } & {\n    [P in K & TPropertyKey]: CodecProto<TVariants[K]>;\n  };\n};\n\ntype VariantCodecProto<\n  TDiscriminator extends TPropertyKey,\n  TVariants extends TProperties,\n> = ProtoVariantMap<TDiscriminator, TVariants>[keyof TVariants];\n\n// Type helper for VariantCodec that preserves the input/output types\nexport type VariantCodec<\n  T extends Codec,\n  TTag extends TPropertyKey,\n  TDiscriminator extends TPropertyKey,\n> = T extends Codec<infer TApp, infer TProto> ? Codec<TApp, TProto> : never;\n\nexport const VariantCodec = <\n  TTag extends TPropertyKey,\n  TDiscriminator extends TPropertyKey,\n  TVariants extends TProperties,\n  TCodec extends Codec<\n    VariantCodecType<TTag, TVariants>,\n    VariantCodecProto<TDiscriminator, TVariants>\n  >,\n>(options: {\n  tag: TTag;\n  discriminator: TDiscriminator;\n  variants: TVariants;\n}): VariantCodec<TCodec, TTag, TDiscriminator> => {\n  return {\n    encode(app) {\n      const tag = app[options.tag];\n      const codec = options.variants[tag];\n      if (!codec) {\n        throw new Error(`Unknown variant: ${String(tag)}`);\n      }\n\n      const variantData = app[tag as keyof typeof app];\n      const encodedData = codec.encode(variantData);\n\n      return {\n        [options.discriminator]: tag,\n        [tag]: encodedData,\n      };\n    },\n    decode(proto) {\n      const tag = proto[options.discriminator];\n      const codec = options.variants[tag];\n      if (!codec) {\n        throw new Error(`Unknown variant: ${String(tag)}`);\n      }\n\n      const variantData = proto[tag as keyof typeof proto];\n      const decodedData = codec.decode(variantData);\n\n      return {\n        [options.tag]: tag,\n        [tag]: decodedData,\n      };\n    },\n  } as VariantCodec<TCodec, TTag, TDiscriminator>;\n};\n\n/*\n    ███████                           ███████       ██████ \n  ███░░░░░███                       ███░░░░░███    ███░░███\n ███     ░░███ ████████    ██████  ███     ░░███  ░███ ░░░ \n░███      ░███░░███░░███  ███░░███░███      ░███ ███████   \n░███      ░███ ░███ ░███ ░███████ ░███      ░███░░░███░    \n░░███     ███  ░███ ░███ ░███░░░  ░░███     ███   ░███     \n ░░░███████░   ████ █████░░██████  ░░░███████░    █████    \n   ░░░░░░░    ░░░░ ░░░░░  ░░░░░░     ░░░░░░░     ░░░░░     \n                                                           \n*/\n\nexport type OneOfCodec<TVariants extends TProperties> = VariantCodec<\n  Codec<\n    VariantCodecType<\"_tag\", TVariants>,\n    VariantCodecProto<\"$case\", TVariants>\n  >,\n  \"_tag\",\n  \"$case\"\n>;\n\nexport function OneOfCodec<TVariants extends TProperties>(\n  variants: TVariants,\n): OneOfCodec<TVariants> {\n  return VariantCodec({\n    tag: \"_tag\",\n    discriminator: \"$case\",\n    variants,\n  });\n}\n"],"names":[],"mappings":"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"}

package/dist/index.cjs

@@ -1,17 +1,19 @@
 'use strict';
 
-const config = require('./shared/protocol.e39e40d6.cjs');
-const schema = require('@effect/schema');
+const config = require('./shared/protocol.53f81a1e.cjs');
+const codec = require('./codec.cjs');
+const assert = require('node:assert');
+const consola = require('consola');
 const niceGrpc = require('nice-grpc');
 require('protobufjs/minimal.js');
-const assert = require('node:assert');
-require('effect');
+const rpc_index = require('./shared/protocol.54f17699.cjs');
 require('viem');
 require('long');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
 const assert__default = /*#__PURE__*/_interopDefaultCompat(assert);
+const consola__default = /*#__PURE__*/_interopDefaultCompat(consola);
 
 const index = {
   __proto__: null,
@@ -19,17 +21,13 @@ const index = {
   testing: config.testing
 };
 
-const StatusRequest = schema.Schema.Struct({});
-const statusRequestToProto = schema.Schema.encodeSync(StatusRequest);
-const statusRequestFromProto = schema.Schema.decodeSync(StatusRequest);
-const StatusResponse = schema.Schema.Struct({
-  currentHead: schema.Schema.optional(config.Cursor),
-  lastIngested: schema.Schema.optional(config.Cursor),
-  finalized: schema.Schema.optional(config.Cursor),
-  starting: schema.Schema.optional(config.Cursor)
+const StatusRequest = codec.MessageCodec({});
+const StatusResponse = codec.MessageCodec({
+  currentHead: codec.OptionalCodec(config.Cursor),
+  lastIngested: codec.OptionalCodec(config.Cursor),
+  finalized: codec.OptionalCodec(config.Cursor),
+  starting: codec.OptionalCodec(config.Cursor)
 });
-const statusResponseToProto = schema.Schema.encodeSync(StatusResponse);
-const statusResponseFromProto = schema.Schema.decodeSync(StatusResponse);
 
 var __defProp$1 = Object.defineProperty;
 var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -57,19 +55,40 @@ function createClient(config$1, streamUrl, options = {}) {
   );
   return new GrpcClient(config$1, client);
 }
+function createAuthenticatedClient(config, streamUrl, options) {
+  const dnaToken = process.env.DNA_TOKEN;
+  if (!dnaToken) {
+    consola__default.warn(
+      "DNA_TOKEN environment variable is not set. Trying to connect without authentication."
+    );
+  }
+  return createClient(config, streamUrl, {
+    ...options,
+    defaultCallOptions: {
+      ...options?.defaultCallOptions ?? {},
+      "*": {
+        metadata: niceGrpc.Metadata({
+          Authorization: `Bearer ${dnaToken}`
+        }),
+        // metadata cant be overrided with spread as its a class so we override it fully if user provided it.
+        ...options?.defaultCallOptions?.["*"] ?? {}
+      }
+    }
+  });
+}
 class GrpcClient {
   constructor(config, client) {
     this.config = config;
     this.client = client;
     __publicField$1(this, "encodeRequest");
-    this.encodeRequest = schema.Schema.encodeSync(config.Request);
+    this.encodeRequest = config.Request.encode;
   }
   async status(request, options) {
     const response = await this.client.status(
-      statusRequestToProto(request ?? {}),
+      StatusRequest.encode(request ?? {}),
       options
     );
-    return statusResponseFromProto(response);
+    return StatusResponse.decode(response);
   }
   streamData(request, options) {
     const it = this.client.streamData(this.encodeRequest(request), options);
@@ -84,8 +103,8 @@ class StreamDataIterable {
   }
   [Symbol.asyncIterator]() {
     const inner = this.it[Symbol.asyncIterator]();
-    const schema$1 = config.StreamDataResponse(this.schema);
-    const decoder = schema.Schema.decodeSync(schema$1);
+    const schema = config.StreamDataResponse(this.schema);
+    const decoder = schema.decode;
     const { endingCursor, timeout = DEFAULT_TIMEOUT_MS } = this.options ?? {};
     let shouldStop = false;
     let clock;
@@ -180,7 +199,6 @@ class RateGauge {
   }
 }
 
-exports.Bytes = config.Bytes;
 exports.BytesFromUint8Array = config.BytesFromUint8Array;
 exports.Cursor = config.Cursor;
 exports.CursorFromBytes = config.CursorFromBytes;
@@ -188,35 +206,32 @@ exports.Data = config.Data;
 exports.DataFinality = config.DataFinality;
 exports.DataProduction = config.DataProduction;
 exports.DnaStreamDefinition = config.DnaStreamDefinition;
-exports.Duration = config.Duration;
+exports.DurationCodec = config.DurationCodec;
 exports.Finalize = config.Finalize;
 exports.Heartbeat = config.Heartbeat;
 exports.Invalidate = config.Invalidate;
+exports.ResponseWithoutData = config.ResponseWithoutData;
 exports.StdErr = config.StdErr;
 exports.StdOut = config.StdOut;
 exports.StreamConfig = config.StreamConfig;
 exports.StreamDataRequest = config.StreamDataRequest;
 exports.StreamDataResponse = config.StreamDataResponse;
 exports.SystemMessage = config.SystemMessage;
-exports._Cursor = config._Cursor;
 exports.createCursor = config.createCursor;
-exports.cursorFromBytes = config.cursorFromBytes;
-exports.cursorFromProto = config.cursorFromProto;
-exports.cursorToBytes = config.cursorToBytes;
-exports.cursorToProto = config.cursorToProto;
 exports.isCursor = config.isCursor;
 exports.normalizeCursor = config.normalizeCursor;
 exports.ClientError = niceGrpc.ClientError;
+exports.Metadata = niceGrpc.Metadata;
+exports.ServerError = niceGrpc.ServerError;
 exports.Status = niceGrpc.Status;
+exports.rpc = rpc_index.index;
 exports.GrpcClient = GrpcClient;
 exports.RateGauge = RateGauge;
 exports.StatusRequest = StatusRequest;
 exports.StatusResponse = StatusResponse;
 exports.StreamDataIterable = StreamDataIterable;
 exports.TimeoutError = TimeoutError;
+exports.createAuthenticatedClient = createAuthenticatedClient;
 exports.createClient = createClient;
 exports.proto = index;
-exports.statusRequestFromProto = statusRequestFromProto;
-exports.statusRequestToProto = statusRequestToProto;
-exports.statusResponseFromProto = statusResponseFromProto;
-exports.statusResponseToProto = statusResponseToProto;
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":["../src/status.ts","../src/client.ts","../src/rate.ts"],"sourcesContent":["import { type CodecType, MessageCodec, OptionalCodec } from \"./codec\";\nimport { Cursor } from \"./common\";\n\n/** The request to the `status` endpoint. */\nexport const StatusRequest = MessageCodec({});\n\nexport type StatusRequest = CodecType<typeof StatusRequest>;\n\n/** The response from the `status` endpoint. */\nexport const StatusResponse = MessageCodec({\n  currentHead: OptionalCodec(Cursor),\n  lastIngested: OptionalCodec(Cursor),\n  finalized: OptionalCodec(Cursor),\n  starting: OptionalCodec(Cursor),\n});\n\nexport type StatusResponse = CodecType<typeof StatusResponse>;\n","import assert from \"node:assert\";\n\nimport consola from \"consola\";\nimport {\n  type ChannelCredentials,\n  type ChannelOptions,\n  type DefaultCallOptions,\n  Metadata,\n  type NormalizedServiceDefinition,\n  createChannel,\n  createClient as grpcCreateClient,\n} from \"nice-grpc\";\n\nimport * as proto from \"./proto\";\n\nimport type { Codec } from \"./codec\";\nimport type { Cursor } from \"./common\";\nimport type { StreamConfig } from \"./config\";\nimport { StatusRequest, StatusResponse } from \"./status\";\nimport { type StreamDataRequest, StreamDataResponse } from \"./stream\";\n\nexport { ClientError, ServerError, Status, Metadata } from \"nice-grpc\";\n\nconst DEFAULT_TIMEOUT_MS = 45_000;\n\nexport class TimeoutError extends Error {\n  constructor(timeout: number) {\n    super(`No message received in ${timeout}ms`);\n    this.name = \"TimeoutError\";\n  }\n}\n\n/** Client call options. */\nexport interface ClientCallOptions {\n  signal?: AbortSignal;\n}\n\nexport interface StreamDataOptions extends ClientCallOptions {\n  /** Stop at the specified cursor (inclusive). */\n  endingCursor?: Cursor;\n  /** Timeout between messages, in milliseconds. */\n  timeout?: number;\n}\n\n/** DNA client. */\nexport interface Client<TFilter, TBlock> {\n  /** Fetch the DNA stream status. */\n  status(\n    request?: StatusRequest,\n    options?: ClientCallOptions,\n  ): Promise<StatusResponse>;\n\n  /** Start streaming data from the DNA server. */\n  streamData(\n    request: StreamDataRequest<TFilter>,\n    options?: StreamDataOptions,\n  ): AsyncIterable<StreamDataResponse<TBlock>>;\n}\n\nexport type CreateClientOptions = {\n  defaultCallOptions?: DefaultCallOptions<\n    NormalizedServiceDefinition<proto.stream.DnaStreamDefinition>\n  >;\n  credentials?: ChannelCredentials;\n  channelOptions?: ChannelOptions;\n};\n\n/** Create a client connecting to the DNA grpc service. */\nexport function createClient<TFilter, TBlock>(\n  config: StreamConfig<TFilter, TBlock>,\n  streamUrl: string,\n  options: CreateClientOptions = {},\n) {\n  const channel = createChannel(\n    streamUrl,\n    options?.credentials,\n    options?.channelOptions,\n  );\n\n  const client: proto.stream.DnaStreamClient = grpcCreateClient(\n    proto.stream.DnaStreamDefinition,\n    channel,\n    options?.defaultCallOptions,\n  );\n\n  return new GrpcClient(config, client);\n}\n\nexport function createAuthenticatedClient<TFilter, TBlock>(\n  config: StreamConfig<TFilter, TBlock>,\n  streamUrl: string,\n  options?: CreateClientOptions,\n) {\n  const dnaToken = process.env.DNA_TOKEN;\n  if (!dnaToken) {\n    consola.warn(\n      \"DNA_TOKEN environment variable is not set. Trying to connect without authentication.\",\n    );\n  }\n\n  return createClient(config, streamUrl, {\n    ...options,\n    defaultCallOptions: {\n      ...(options?.defaultCallOptions ?? {}),\n      \"*\": {\n        metadata: Metadata({\n          Authorization: `Bearer ${dnaToken}`,\n        }),\n        // metadata cant be overrided with spread as its a class so we override it fully if user provided it.\n        ...(options?.defaultCallOptions?.[\"*\"] ?? {}),\n      },\n    },\n  });\n}\n\nexport class GrpcClient<TFilter, TBlock> implements Client<TFilter, TBlock> {\n  private encodeRequest;\n\n  constructor(\n    private config: StreamConfig<TFilter, TBlock>,\n    private client: proto.stream.DnaStreamClient,\n  ) {\n    this.encodeRequest = config.Request.encode;\n  }\n\n  async status(request?: StatusRequest, options?: ClientCallOptions) {\n    const response = await this.client.status(\n      StatusRequest.encode(request ?? {}),\n      options,\n    );\n    return StatusResponse.decode(response);\n  }\n\n  streamData(request: StreamDataRequest<TFilter>, options?: StreamDataOptions) {\n    const it = this.client.streamData(this.encodeRequest(request), options);\n    return new StreamDataIterable(it, this.config.Block, options);\n  }\n}\n\nexport class StreamDataIterable<TBlock> {\n  constructor(\n    private it: AsyncIterable<proto.stream.StreamDataResponse>,\n    private schema: Codec<TBlock, Uint8Array>,\n    private options?: StreamDataOptions,\n  ) {}\n\n  [Symbol.asyncIterator](): AsyncIterator<StreamDataResponse<TBlock>> {\n    const inner = this.it[Symbol.asyncIterator]();\n    const schema = StreamDataResponse(this.schema);\n    const decoder = schema.decode;\n    const { endingCursor, timeout = DEFAULT_TIMEOUT_MS } = this.options ?? {};\n    let shouldStop = false;\n\n    let clock: string | number | NodeJS.Timeout | undefined;\n\n    return {\n      async next() {\n        if (shouldStop) {\n          return { done: true, value: undefined };\n        }\n\n        // biome-ignore lint/suspicious/noExplicitAny: any is ok\n        const t: Promise<{ done: boolean; value: any }> = new Promise(\n          (_, reject) => {\n            clock = setTimeout(() => {\n              reject(new TimeoutError(timeout));\n            }, timeout);\n          },\n        );\n\n        try {\n          const { done, value } = await Promise.race([inner.next(), t]);\n\n          clearTimeout(clock);\n\n          if (done || value.message === undefined) {\n            return { done: true, value: undefined };\n          }\n\n          const decodedMessage = decoder(value.message);\n\n          if (endingCursor) {\n            assert(value.message.$case === \"data\");\n            assert(decodedMessage._tag === \"data\");\n\n            const { orderKey, uniqueKey } = endingCursor;\n            const endCursor = decodedMessage.data.endCursor;\n\n            // Check if the orderKey matches\n            if (orderKey === endCursor?.orderKey) {\n              // If a uniqueKey is specified, it must also match\n              if (!uniqueKey || uniqueKey === endCursor.uniqueKey) {\n                shouldStop = true;\n                return { done: false, value: decodedMessage };\n              }\n            }\n          }\n\n          return {\n            done: false,\n            value: decodedMessage,\n          };\n        } finally {\n          clearTimeout(clock);\n        }\n      },\n    };\n  }\n}\n","/** Track data rate using high precision timers. */\nexport class RateGauge {\n  private interval: number;\n  private prev?: bigint;\n  private rateMs?: number;\n  private var: number;\n\n  constructor(intervalSeconds: number) {\n    // Convert seconds to milliseconds.\n    this.interval = intervalSeconds * 1_000;\n    this.var = 0;\n  }\n\n  public record(items: number) {\n    // Compute the exponential moving average of the rate.\n    const prev = this.prev;\n    const now = process.hrtime.bigint();\n    this.prev = now;\n\n    if (!prev) {\n      return;\n    }\n\n    const deltaMs = Number(now - prev) / 1_000_000;\n    // rate in items/ms.\n    const rateMs = items / deltaMs;\n\n    if (this.rateMs === undefined) {\n      this.rateMs = rateMs;\n      this.var = 0;\n      return;\n    }\n\n    const alpha = 1 - Math.exp(-deltaMs / this.interval);\n    this.rateMs = alpha * rateMs + (1 - alpha) * this.rateMs;\n\n    const diff = rateMs - this.rateMs;\n    const incr = alpha * diff;\n    this.var = (1 - alpha) * (this.var + incr * diff);\n  }\n\n  /** Returns the average rate per second. */\n  public average() {\n    if (this.rateMs === undefined) {\n      return undefined;\n    }\n    return this.rateMs * 1_000;\n  }\n\n  /** Returns the variance. */\n  public variance() {\n    return this.var;\n  }\n}\n"],"names":["MessageCodec","OptionalCodec","Cursor","config","createChannel","grpcCreateClient","proto.stream.DnaStreamDefinition","consola","Metadata","__publicField","StreamDataResponse","assert"],"mappings":"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"}

package/dist/index.d.cts

@@ -1,10 +1,10 @@
-import { s as stream } from './shared/protocol.4b1cfe2c.cjs';
-export { B as Bytes, b as BytesFromUint8Array, J as Client, E as ClientCallOptions, K as CreateClientOptions, c as Cursor, g as CursorFromBytes, C as CursorProto, y as Data, q as DataFinality, r as DataProduction, D as DnaStreamClient, a as DnaStreamDefinition, t as Duration, F as Finalize, M as GrpcClient, H as Heartbeat, I as Invalidate, S as StatusRequest, m as StatusResponse, w as StdErr, v as StdOut, A as StreamConfig, N as StreamDataIterable, G as StreamDataOptions, u as StreamDataRequest, z as StreamDataResponse, x as SystemMessage, T as TimeoutError, _ as _Cursor, L as createClient, d as createCursor, i as cursorFromBytes, f as cursorFromProto, h as cursorToBytes, e as cursorToProto, j as isCursor, n as normalizeCursor, l as statusRequestFromProto, k as statusRequestToProto, p as statusResponseFromProto, o as statusResponseToProto } from './shared/protocol.4b1cfe2c.cjs';
+import { s as stream } from './shared/protocol.0e734e33.cjs';
+export { B as Bytes, b as BytesFromUint8Array, w as Client, u as ClientCallOptions, x as CreateClientOptions, C as Cursor, e as CursorFromBytes, c as CursorProto, q as Data, g as DataFinality, h as DataProduction, D as DnaStreamClient, a as DnaStreamDefinition, k as Duration, j as DurationCodec, F as Finalize, G as GrpcClient, H as Heartbeat, I as Invalidate, R as ResponseWithoutData, S as StatusRequest, f as StatusResponse, o as StdErr, m as StdOut, t as StreamConfig, A as StreamDataIterable, v as StreamDataOptions, l as StreamDataRequest, r as StreamDataResponse, p as SystemMessage, T as TimeoutError, z as createAuthenticatedClient, y as createClient, d as createCursor, i as isCursor, n as normalizeCursor } from './shared/protocol.0e734e33.cjs';
 import _m0 from 'protobufjs/minimal.js';
-export { ClientError, Status } from 'nice-grpc';
-import '@effect/schema';
+export { i as rpc } from './shared/protocol.7aa4aab6.cjs';
+export { ClientError, Metadata, ServerError, Status } from 'nice-grpc';
+import './codec.cjs';
 import 'nice-grpc-common';
-import '@effect/schema/AST';
 
 declare const protobufPackage = "dna.v2.testing";
 interface MockFilter {

package/dist/index.d.mts

@@ -1,10 +1,10 @@
-import { s as stream } from './shared/protocol.4b1cfe2c.mjs';
-export { B as Bytes, b as BytesFromUint8Array, J as Client, E as ClientCallOptions, K as CreateClientOptions, c as Cursor, g as CursorFromBytes, C as CursorProto, y as Data, q as DataFinality, r as DataProduction, D as DnaStreamClient, a as DnaStreamDefinition, t as Duration, F as Finalize, M as GrpcClient, H as Heartbeat, I as Invalidate, S as StatusRequest, m as StatusResponse, w as StdErr, v as StdOut, A as StreamConfig, N as StreamDataIterable, G as StreamDataOptions, u as StreamDataRequest, z as StreamDataResponse, x as SystemMessage, T as TimeoutError, _ as _Cursor, L as createClient, d as createCursor, i as cursorFromBytes, f as cursorFromProto, h as cursorToBytes, e as cursorToProto, j as isCursor, n as normalizeCursor, l as statusRequestFromProto, k as statusRequestToProto, p as statusResponseFromProto, o as statusResponseToProto } from './shared/protocol.4b1cfe2c.mjs';
+import { s as stream } from './shared/protocol.21e66b9e.mjs';
+export { B as Bytes, b as BytesFromUint8Array, w as Client, u as ClientCallOptions, x as CreateClientOptions, C as Cursor, e as CursorFromBytes, c as CursorProto, q as Data, g as DataFinality, h as DataProduction, D as DnaStreamClient, a as DnaStreamDefinition, k as Duration, j as DurationCodec, F as Finalize, G as GrpcClient, H as Heartbeat, I as Invalidate, R as ResponseWithoutData, S as StatusRequest, f as StatusResponse, o as StdErr, m as StdOut, t as StreamConfig, A as StreamDataIterable, v as StreamDataOptions, l as StreamDataRequest, r as StreamDataResponse, p as SystemMessage, T as TimeoutError, z as createAuthenticatedClient, y as createClient, d as createCursor, i as isCursor, n as normalizeCursor } from './shared/protocol.21e66b9e.mjs';
 import _m0 from 'protobufjs/minimal.js';
-export { ClientError, Status } from 'nice-grpc';
-import '@effect/schema';
+export { i as rpc } from './shared/protocol.6ab8d6dd.mjs';
+export { ClientError, Metadata, ServerError, Status } from 'nice-grpc';
+import './codec.mjs';
 import 'nice-grpc-common';
-import '@effect/schema/AST';
 
 declare const protobufPackage = "dna.v2.testing";
 interface MockFilter {

package/dist/index.d.ts

@@ -1,10 +1,10 @@
-import { s as stream } from './shared/protocol.4b1cfe2c.js';
-export { B as Bytes, b as BytesFromUint8Array, J as Client, E as ClientCallOptions, K as CreateClientOptions, c as Cursor, g as CursorFromBytes, C as CursorProto, y as Data, q as DataFinality, r as DataProduction, D as DnaStreamClient, a as DnaStreamDefinition, t as Duration, F as Finalize, M as GrpcClient, H as Heartbeat, I as Invalidate, S as StatusRequest, m as StatusResponse, w as StdErr, v as StdOut, A as StreamConfig, N as StreamDataIterable, G as StreamDataOptions, u as StreamDataRequest, z as StreamDataResponse, x as SystemMessage, T as TimeoutError, _ as _Cursor, L as createClient, d as createCursor, i as cursorFromBytes, f as cursorFromProto, h as cursorToBytes, e as cursorToProto, j as isCursor, n as normalizeCursor, l as statusRequestFromProto, k as statusRequestToProto, p as statusResponseFromProto, o as statusResponseToProto } from './shared/protocol.4b1cfe2c.js';
+import { s as stream } from './shared/protocol.8fb09325.js';
+export { B as Bytes, b as BytesFromUint8Array, w as Client, u as ClientCallOptions, x as CreateClientOptions, C as Cursor, e as CursorFromBytes, c as CursorProto, q as Data, g as DataFinality, h as DataProduction, D as DnaStreamClient, a as DnaStreamDefinition, k as Duration, j as DurationCodec, F as Finalize, G as GrpcClient, H as Heartbeat, I as Invalidate, R as ResponseWithoutData, S as StatusRequest, f as StatusResponse, o as StdErr, m as StdOut, t as StreamConfig, A as StreamDataIterable, v as StreamDataOptions, l as StreamDataRequest, r as StreamDataResponse, p as SystemMessage, T as TimeoutError, z as createAuthenticatedClient, y as createClient, d as createCursor, i as isCursor, n as normalizeCursor } from './shared/protocol.8fb09325.js';
 import _m0 from 'protobufjs/minimal.js';
-export { ClientError, Status } from 'nice-grpc';
-import '@effect/schema';
+export { i as rpc } from './shared/protocol.8407f25e.js';
+export { ClientError, Metadata, ServerError, Status } from 'nice-grpc';
+import './codec.js';
 import 'nice-grpc-common';
-import '@effect/schema/AST';
 
 declare const protobufPackage = "dna.v2.testing";
 interface MockFilter {