docs: correct grammatical errors

Author: DaxServer

docs/blog/elysia-10.md

@@ -45,7 +45,7 @@ head:
 
 Elysia 1.0 is the first stable release after development for 1.8 years.
 
-Since started, we have always waiting for a framework that focuses on developer experience, velocity, and how to make writing code for humans, not a machine.
+Since we started, we have always been waiting for a framework that focuses on developer experience, velocity, and how to make writing code for humans, not a machine.
 
 We battle-test Elysia in various situations, simulate medium and large-scale projects, shipping code to clients and this is the first version that we felt confident enough to ship.
 

docs/blog/elysia-11.md

@@ -89,7 +89,7 @@ new Elysia()
 
 ![jaeger showing collected trace automatically](/blog/elysia-11/jaeger.webp)
 
-Elysia OpenTelemetry is will **collect span of any library compatible OpenTelemetry standard**, and will apply parent and child span automatically.
+Elysia OpenTelemetry will **collect span of any library compatible with the OpenTelemetry standard**, and will apply parent and child span automatically.
 
 In the code above, we apply `Prisma` to trace how long each query took.
 

docs/blog/elysia-12.md

@@ -10,11 +10,11 @@ head:
 
     - - meta
       - name: 'description'
-        content: Introducing Adapter for universal runtime suppport, Object macro with resolve, Parser with custom name, WebSocket with lifecycle, TypeBox 0.34 with recursive type, and Eden validation inference.
+        content: Introducing Adapter for universal runtime support, Object macro with resolve, Parser with custom name, WebSocket with lifecycle, TypeBox 0.34 with recursive type, and Eden validation inference.
 
     - - meta
       - property: 'og:description'
-        content: Introducing Adapter for universal runtime suppport, Object macro with resolve, Parser with custom name, WebSocket with lifecycle, TypeBox 0.34 with recursive type, and Eden validation inference.
+        content: Introducing Adapter for universal runtime support, Object macro with resolve, Parser with custom name, WebSocket with lifecycle, TypeBox 0.34 with recursive type, and Eden validation inference.
 
     - - meta
       - property: 'og:image'
@@ -38,9 +38,9 @@ head:
     shadow
 >
 
-Named after the song [Φ²](https://youtu.be/b9IkzWO63Fg) from album "At the Fingertip of the Sea" by HoyoMix as used in as in [**"You and Me"**](https://youtu.be/nz_Ra4G57A4).
+Named after the song [Φ²](https://youtu.be/b9IkzWO63Fg) from album "At the Fingertip of the Sea" by HoyoMix as used in [**"You and Me"**](https://youtu.be/nz_Ra4G57A4).
 
-Elysia 1.2 focus on commitment to expand universal runtime support and developer experience:
+Elysia 1.2 focuses on commitment to expand universal runtime support and developer experience:
 - [Adapter](#adapter)
 - [Macro with resolve](#macro-with-resolve)
 - [Parser](#parser)
@@ -92,7 +92,7 @@ We will continue to expand support for more runtimes in the future starting with
 - uWebSocket.js
 
 ### Universal runtime API
-To be comaptible with different runtime, Elysia now wrap over a hand-picked utility function to provide a consistent API across different runtime.
+To be compatible with different runtime, Elysia now wraps over a hand-picked utility function to provide a consistent API across different runtime.
 
 For example, in Bun you may use `Bun.file` to return a file response which is not available in Node.
 

docs/blog/elysia-13.md

@@ -102,7 +102,7 @@ When comparing to the same code **without schema**, we see < 2% performance diff
 
 This is huge.
 
-Previously, you have to choose between safety and performance but as we close the performance gap between using and not using validation. But now you don't have to worry about it.
+Previously, you had to choose between safety and performance as we close the performance gap between using and not using validation. But now you don't have to worry about it.
 
 But now, we drop validation overhead from a significant amount to almost near zero without requiring any changes on your side.
 
@@ -150,13 +150,13 @@ We can then override a public schema by providing a schema in a route handler wh
 ![Elysia run with default override guard showing schema gets override](/blog/elysia-13/schema-override.webp)
 > Elysia run with default override guard
 
-But sometime we **don't want to override** a schema.
+But sometimes we **don't want to override** a schema.
 
 Instead we want it to work both allowing us to combine schemas instead of overriding them.
 
 Starting from Elysia 1.3, we can do just that.
 
-We can now tell Elysia to not to override it and instead treat it as its own by providing a schema as **standalone**.
+We can now tell Elysia not to override it and instead treat it as its own by providing a schema as **standalone**.
 
 ```ts
 import { Elysia } from 'elysia'
@@ -170,7 +170,7 @@ new Elysia()
 	})
 ```
 
-As a result, we have a results that like merging a local and global schema together.
+As a result, we have results that are like merging a local and global schema together.
 
 ![Elysia run with standalone merging multiple guard together](/blog/elysia-13/schema-standalone.webp)
 > Elysia run with standalone merging multiple guard together
@@ -181,7 +181,7 @@ Elysia's type inference is already extremely fast.
 
 We are really confident in our optimization of type inference and it's faster than most frameworks that use an express-like syntax.
 
-However, our users with really **really** large scale with multiple routes and complex type inference.
+However, our users with really **really** large scale applications with multiple routes and complex type inference.
 
 We managed to **reduce type instantiation by half** in most cases, and measured up to 60% improvement in inference speed.
 
@@ -195,7 +195,7 @@ This should solve the problem with users who use heavy object/class for example
 As a result, we should end up with faster IDE auto-completion, suggestion, type checking and Eden Treaty.
 
 ## Performance Improvement
-We have refactored and optimized a lot of internal code which accumulate up to significant improvements.
+We have refactored and optimized a lot of internal code which accumulates up to significant improvements.
 
 ### Route Registration
 

docs/eden/fetch.md

@@ -15,9 +15,9 @@ head:
 ---
 
 # Eden Fetch
-A fetch-like alternative to Eden Treaty .
+A fetch-like alternative to Eden Treaty.
 
-With Eden Fetch can interact with Elysia server in a type-safe manner using Fetch API.
+With Eden Fetch, you can interact with Elysia server in a type-safe manner using Fetch API.
 
 ---
 

docs/eden/treaty/config.md

@@ -34,21 +34,21 @@ import type { App } from './server'
 const api = treaty<App>('localhost:3000')
 ```
 
-You may or may not specified a protocol for URL endpoint.
+You may or may not specify a protocol for URL endpoint.
 
-Elysia will appends the endpoints automatically as follows:
+Elysia will append the endpoints automatically as follows:
 1. If protocol is specified, use the URL directly
 2. If the URL is localhost and ENV is not production, use http
 3. Otherwise use https
 
-This also apply to Web Socket as well for determining between **ws://** or **wss://**.
+This also applies to Web Socket as well for determining between **ws://** or **wss://**.
 
 ---
 
 ### Elysia Instance
 If Elysia instance is passed, Eden Treaty will create a `Request` class and pass to `Elysia.handle` directly without creating a network request.
 
-This allows us to interact with Elysia server directly without request overhead, or the need start a server.
+This allows us to interact with Elysia server directly without request overhead, or the need to start a server.
 
 ```typescript
 import { Elysia } from 'elysia'
@@ -61,13 +61,13 @@ const app = new Elysia()
 const api = treaty(app)
 ```
 
-If an instance is passed, generic is not needed to be pass as Eden Treaty can infers the type from a parameter directly.
+If an instance is passed, generic is not needed to be passed as Eden Treaty can infer the type from a parameter directly.
 
-This patterns is recommended for performing unit tests, or creating a type-safe reverse proxy server or micro-services.
+This pattern is recommended for performing unit tests, or creating a type-safe reverse proxy server or micro-services.
 
 ## Options
-2nd optional parameters for Eden Treaty to customize fetch behavior, accepting parameters as follows:
-- [fetch](#fetch) - add default parameters to fetch intialization (RequestInit)
+2nd optional parameter for Eden Treaty to customize fetch behavior, accepting parameters as follows:
+- [fetch](#fetch) - add default parameters to fetch initialization (RequestInit)
 - [headers](#headers) - define default headers
 - [fetcher](#fetcher) - custom fetch function eg. Axios, unfetch
 - [onRequest](#onrequest) - Intercept and modify fetch request before firing
@@ -87,7 +87,7 @@ treaty<App>('localhost:3000', {
 })
 ```
 
-All parameters that passed to fetch, will be passed to fetcher, which is an equivalent to:
+All parameters that are passed to fetch will be passed to fetcher, which is equivalent to:
 ```typescript
 fetch('http://localhost:3000', {
     credentials: 'include'
@@ -114,7 +114,7 @@ fetch('localhost:3000', {
 })
 ```
 
-headers may accepts the following as parameters:
+headers may accept the following as parameters:
 - Object
 - Function
 
@@ -130,7 +130,7 @@ treaty<App>('localhost:3000', {
 ```
 
 ### Function
-You may specify a headers as a function to return custom headers based on condition
+You may specify headers as a function to return custom headers based on condition
 
 ```typescript
 treaty<App>('localhost:3000', {
@@ -151,7 +151,7 @@ headers function accepts 2 parameters:
 - options `RequestInit`: Parameters that passed through 2nd parameter of fetch
 
 ### Array
-You may define a headers function as an array if multiple conditions are need.
+You may define a headers function as an array if multiple conditions are needed.
 
 ```typescript
 treaty<App>('localhost:3000', {
@@ -172,7 +172,7 @@ Eden Treaty will **run all functions** even if the value is already returned.
 Eden Treaty will prioritize the order headers if duplicated as follows:
 1. Inline method - Passed in method function directly
 2. headers - Passed in `config.headers`
-  - If `config.headers` is array, parameters that come after will be prioritize
+  - If `config.headers` is array, parameters that come after will be prioritized
 3. fetch - Passed in `config.fetch.headers`
 
 For example, for the following example:
@@ -190,7 +190,7 @@ api.profile.get({
 })
 ```
 
-This will be results in:
+This will result in:
 ```typescript
 fetch('http://localhost:3000', {
     headers: {

docs/eden/treaty/response.md

@@ -7,11 +7,11 @@ head:
 
     - - meta
       - name: 'og:description'
-        content: Eden Treaty is an object-like representation of an Elysia server, providing an end-to-end type safety, and a significantly improved developer experience. With Eden, we can fetch an API from Elysia server fully type-safe without code generation.
+        content: Eden Treaty is an object-like representation of an Elysia server, providing end-to-end type safety and a significantly improved developer experience. With Eden, we can fetch an API from Elysia server fully type-safe without code generation.
 
     - - meta
       - name: 'og:description'
-        content: Eden Treaty is an object-like representation of an Elysia server, providing an end-to-end type safety, and a significantly improved developer experience. With Eden, we can fetch an API from Elysia server fully type-safe without code generation.
+        content: Eden Treaty is an object-like representation of an Elysia server, providing end-to-end type safety and a significantly improved developer experience. With Eden, we can fetch an API from Elysia server fully type-safe without code generation.
 ---
 
 # Response
@@ -70,7 +70,7 @@ const submit = async (name: string) => {
 By default, Elysia infers `error` and `response` types to TypeScript automatically, and Eden will be providing auto-completion and type narrowing for accurate behavior.
 
 ::: tip
-If the server responds with an HTTP status >= 300, then the value will be always be `null`, and `error` will have a returned value instead.
+If the server responds with an HTTP status >= 300, then the value will always be `null`, and `error` will have a returned value instead.
 
 Otherwise, response will be passed to `data`.
 :::

docs/eden/treaty/unit-test.md

@@ -7,17 +7,17 @@ head:
 
     - - meta
       - name: 'og:description'
-        content: Eden Treaty is an object-like representation of an Elysia server, providing an end-to-end type safety, and a significantly improved developer experience. With Eden, we can fetch an API from Elysia server fully type-safe without code generation.
+        content: Eden Treaty is an object-like representation of an Elysia server, providing end-to-end type safety and a significantly improved developer experience. With Eden, we can fetch an API from Elysia server fully type-safe without code generation.
 
     - - meta
       - name: 'og:description'
-        content: Eden Treaty is an object-like representation of an Elysia server, providing an end-to-end type safety, and a significantly improved developer experience. With Eden, we can fetch an API from Elysia server fully type-safe without code generation.
+        content: Eden Treaty is an object-like representation of an Elysia server, providing end-to-end type safety and a significantly improved developer experience. With Eden, we can fetch an API from Elysia server fully type-safe without code generation.
 ---
 
 # Unit Test
 According to [Eden Treaty config](/eden/treaty/config.html#urlorinstance) and [Unit Test](/patterns/unit-test), we may pass an Elysia instance to Eden Treaty directly to interact with Elysia server directly without sending a network request.
 
-We may use this patterns to create a unit test with end-to-end type safety and type-level test all at once.
+We may use this pattern to create a unit test with end-to-end type safety and type-level test all at once.
 
 ```typescript twoslash
 // test/index.test.ts
@@ -29,7 +29,7 @@ const app = new Elysia().get('/hello', 'hi')
 const api = treaty(app)
 
 describe('Elysia', () => {
-    it('return a response', async () => {
+    it('returns a response', async () => {
         const { data } = await api.hello.get()
 
         expect(data).toBe('hi')
@@ -40,7 +40,7 @@ describe('Elysia', () => {
 ```
 
 ## Type safety test
-To perform a type safety test, simply run **tsc** to test folders.
+To perform a type safety test, simply run **tsc** on test folders.
 
 ```bash
 tsc --noEmit test/**/*.ts

docs/essential/best-practice.md

@@ -7,26 +7,26 @@ head:
 
     - - meta
       - name: 'description'
-        content: Elysia is pattern agnostic framework, we leave the decision up to you and your team for coding patterns to use. However, we found that there are several who are using MVC pattern (Model-View-Controller) on Elysia, and found it's hard to decouple and handling with types. This page is a guide to use Elysia with MVC pattern.
+        content: Elysia is a pattern agnostic framework, we leave the decision up to you and your team for coding patterns to use. However, we found that there are several who are using MVC pattern (Model-View-Controller) on Elysia, and found it's hard to decouple and handle types. This page is a guide to use Elysia with MVC pattern.
 
     - - meta
       - property: 'og:description'
-        content: Elysia is pattern agnostic framework, we the decision up to you and your team for coding patterns to use. However, we found that there are several who are using MVC pattern (Model-View-Controller) on Elysia, and found it's hard to decouple and handling with types. This page is a guide to use Elysia with MVC pattern.
+        content: Elysia is a pattern agnostic framework, we leave the decision up to you and your team for coding patterns to use. However, we found that there are several who are using MVC pattern (Model-View-Controller) on Elysia, and found it's hard to decouple and handle types. This page is a guide to use Elysia with MVC pattern.
 ---
 
 # Best Practice
 
 Elysia is a pattern-agnostic framework, leaving the decision of which coding patterns to use up to you and your team.
 
-However, there are several concern from trying to adapt an MVC pattern [(Model-View-Controller)](https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller) with Elysia, and found it's hard to decouple and handle types.
+However, there are several concerns from trying to adapt an MVC pattern [(Model-View-Controller)](https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller) with Elysia, and we found it's hard to decouple and handle types.
 
-This page is a guide to on how to follows Elysia structure best practice combined with MVC pattern but can be adapted to any coding pattern you like.
+This page is a guide on how to follow Elysia structure best practices combined with MVC pattern but can be adapted to any coding pattern you like.
 
 ## Folder Structure
 
 Elysia is unopinionated about folder structure, leaving you to **decide** how to organize your code yourself.
 
-However, **if you doesn't have a specific structure in mind**, we recommended a feature-based folder structure. Where each feature has its own folder containing controllers, services, models.
+However, **if you don't have a specific structure in mind**, we recommend a feature-based folder structure. Where each feature has its own folder containing controllers, services, and models.
 
 ```
 | src

docs/essential/handler.md

@@ -102,7 +102,7 @@ new Elysia()
     .listen(3000)
 ```
 
-Handler maybe a literal value, and can be inlined.
+A handler may be a literal value, and can be inlined.
 
 ```typescript
 import { Elysia, file } from 'elysia'
@@ -113,19 +113,19 @@ new Elysia()
     .listen(3000)
 ```
 
-Using an inline value always returns the same value which is useful to optimize performance for static resource like file.
+Using an inline value always returns the same value which is useful to optimize performance for static resources like files.
 
 This allows Elysia to compile the response ahead of time to optimize performance.
 
 ::: tip
 Providing an inline value is not a cache.
 
-Static Resource value, headers and status can be mutate dynamically using lifecycle.
+Static resource values, headers and status can be mutated dynamically using lifecycle.
 :::
 
 ## Context
 
-**Context** contains a request information which unique for each request, and is not shared except for `store` <small>(global mutable state)</small>.
+**Context** contains request information which is unique for each request, and is not shared except for `store` <small>(global mutable state)</small>.
 
 ```typescript twoslash
 import { Elysia } from 'elysia'
@@ -204,10 +204,10 @@ new Elysia()
 
 <Playground :elysia="handler2" />
 
-It's recommend to use `status` inside main handler as it has better inference:
+It's recommended to use `status` inside the main handler as it has better inference:
 
 - allows TypeScript to check if a return value is correctly type to response schema
-- autocompletion for type narrowing base on status code
+- autocompletion for type narrowing based on status code
 - type narrowing for error handling using End-to-end type safety ([Eden](/eden/overview))
 
 ### set.status
@@ -251,7 +251,7 @@ new Elysia()
 ```
 
 ### set.headers
-Allowing us to append or delete a response headers represent as Object.
+Allowing us to append or delete response headers represented as an Object.
 
 ```typescript twoslash
 import { Elysia } from 'elysia'