### Serialize Maps with Zucchini

Source: https://context7.com/mark-marks/zucchini/llms.txt

Serializes key-value dictionaries. This example shows serializing a map with string keys and vector values. The library handles the mapping of keys and values to their serialized forms.

```luau
local cursor = zucchini.cursor()

-- String keys, vector values
local position_map = zucchini.map { [zucchini.string] = zucchini.vector }

local positions = {
    spawn = vector.create(0, 10, 0),
    checkpoint1 = vector.create(100, 15, 50),
    boss_room = vector.create(500, 0, 200),
}

position_map.ser(cursor, positions)
local result = position_map.des(cursor)
-- result.spawn = vector(0, 10, 0)
-- result.checkpoint1 = vector(100, 15, 50)
-- result.boss_room = vector(500, 0, 200)
```

--------------------------------

### Dynamic Serialization and Deserialization with Zucchini

Source: https://github.com/mark-marks/zucchini/blob/main/README.md

This example illustrates Zucchini's capability to dynamically serialize and deserialize unknown data structures. It serializes a complex, arbitrarily nested table and then deserializes it back to its original form.

```luau
local my_data = {
    this = "is some random data",
    which = {
        you = {
            do = "not know anything about",
        },
        some_number = 1234,
    },
    and_it_works = "!",
    catch_them_all = nil,
    and_more = vector.create(12, 64),
}

local cursor = squash.cursor()
zucchini.unknown.ser(cursor, my_data)

local my_data_out = zucchini.unknown.des(cursor) -- The exact same as `my_data`
```

--------------------------------

### Serialize Records with Zucchini

Source: https://context7.com/mark-marks/zucchini/llms.txt

Serializes structured objects with named fields of different types. This example defines a complex player record including nested arrays and maps, and demonstrates serialization and deserialization.

```luau
local cursor = zucchini.cursor()

local player_serdes = zucchini.record {
    position = zucchini.vector,
    health = zucchini.uint8,
    name = zucchini.string,
    poisoned = zucchini.boolean,
    grappled = zucchini.boolean,
    concious = zucchini.boolean,
    items = zucchini.array {
        zucchini.record {
            count = zucchini.vlq,
            name = zucchini.string,
        },
    },
    inns = zucchini.map { [zucchini.string] = zucchini.boolean },
    equipped = zucchini.opt { zucchini.string },
}

local player = {
    position = vector.create(287.3855, -13486.3, 0),
    health = 9,
    name = "Cedrick",
    poisoned = true,
    grappled = true,
    concious = false,
    items = {
        { name = "Lantern", count = 2 },
        { name = "Waterskin", count = 1 },
        { name = "Map", count = 4 },
    },
    inns = {
        ["The Copper Cauldron"] = true,
        ["Infirmary"] = true,
        ["His Recess"] = true,
    },
    equipped = nil,
}

player_serdes.ser(cursor, player)
local restored_player = player_serdes.des(cursor)
-- restored_player is structurally identical to player
```

--------------------------------

### Create Zucchini Cursor

Source: https://context7.com/mark-marks/zucchini/llms.txt

Demonstrates how to create a new Zucchini cursor, either with default settings for writing or from an existing buffer for reading.

```luau
local zucchini = require("zucchini")

-- Create a new cursor with default buffer size (8 bytes, auto-resizes)
local cursor = zucchini.cursor()

-- Create a cursor from an existing buffer (for deserialization)
local existing_buffer = buffer.create(64)
local cursor_from_buf = zucchini.cursor_from_buffer(existing_buffer)
```

--------------------------------

### Buffer Serialization in Zucchini

Source: https://context7.com/mark-marks/zucchini/llms.txt

Demonstrates how to serialize and deserialize raw binary buffers using Zucchini. Supports both dynamic-length buffers and fixed-length buffers with a specified size.

```luau
local cursor = zucchini.cursor()

-- Dynamic length buffer
local buf = buffer.create(8)
buffer.writeu32(buf, 0, 12345678)

zucchini.buffer.ser(cursor, buf)
local result = zucchini.buffer.des(cursor)
print(buffer.readu32(result, 0)) -- 12345678

-- Fixed length buffer
local fixed_buf_serdes = zucchini.buffer { 4 }
fixed_buf_serdes.ser(cursor, buf)
```

--------------------------------

### String Serialization in Zucchini

Source: https://context7.com/mark-marks/zucchini/llms.txt

Illustrates Zucchini's string serialization, supporting both dynamic-length strings (with a length prefix) and fixed-length strings (exact byte count).

```luau
local cursor = zucchini.cursor()

-- Dynamic length (length prefix + string data)
local dynamic_string = zucchini.string
dynamic_string.ser(cursor, "Hello, World!")
local str = dynamic_string.des(cursor) -- "Hello, World!"

-- Fixed length (no length prefix, exact bytes)
local fixed_string = zucchini.string { 13 }
fixed_string.ser(cursor, "Hello, World!")
local fixed_str = fixed_string.des(cursor) -- "Hello, World!"
```

--------------------------------

### Serialize Floating-Point Numbers with Zucchini

Source: https://context7.com/mark-marks/zucchini/llms.txt

Demonstrates the serialization and deserialization of 32-bit and 64-bit floating-point numbers using Zucchini. This allows for accurate representation of decimal values in binary format.

```luau
local cursor = zucchini.cursor()

-- 32-bit float (4 bytes)
zucchini.f32.ser(cursor, 3.14159)
local pi_32 = zucchini.f32.des(cursor)

-- 64-bit float (8 bytes, higher precision)
zucchini.f64.ser(cursor, 2.718281828459045)
local e = zucchini.f64.des(cursor)
```

--------------------------------

### Serialize Integers with Zucchini

Source: https://context7.com/mark-marks/zucchini/llms.txt

Illustrates serialization of both unsigned and signed integers with Zucchini, supporting bit widths from 8 to 64 bits. This allows for precise control over data size and representation.

```luau
local cursor = zucchini.cursor()

-- Unsigned integers
zucchini.uint8.ser(cursor, 255)        -- 1 byte (0-255)
zucchini.uint16.ser(cursor, 65535)     -- 2 bytes (0-65535)
zucchini.uint24.ser(cursor, 16777215)  -- 3 bytes
zucchini.uint32.ser(cursor, 4294967295) -- 4 bytes
zucchini.uint40.ser(cursor, 1099511627775) -- 5 bytes
zucchini.uint48.ser(cursor, 281474976710655) -- 6 bytes
zucchini.uint56.ser(cursor, 72057594037927935) -- 7 bytes
zucchini.uint64.ser(cursor, 9007199254740991) -- 8 bytes

-- Signed integers
zucchini.int8.ser(cursor, -128)        -- 1 byte (-128 to 127)
zucchini.int16.ser(cursor, -32768)     -- 2 bytes
zucchini.int24.ser(cursor, -8388608)   -- 3 bytes
zucchini.int32.ser(cursor, -2147483648) -- 4 bytes

-- Deserialize
local value = zucchini.uint8.des(cursor)
```

--------------------------------

### Base Conversion Utilities in Luau with Zucchini

Source: https://context7.com/mark-marks/zucchini/llms.txt

Perform base conversions between different alphabets and bases using Zucchini's utility functions. This includes predefined alphabets like binary, octal, decimal, hexadecimal, and custom alphabet creation.

```luau
local zucchini = require("zucchini")

-- Available alphabets
local binary = zucchini.base_conversion.binary         -- "01"
local octal = zucchini.base_conversion.octal           -- "01234567"
local decimal = zucchini.base_conversion.decimal       -- "0123456789"
local hexadecimal = zucchini.base_conversion.hexadecimal -- "0123456789ABCDEF"
local lower = zucchini.base_conversion.lower           -- "abcdefghijklmnopqrstuvwxyz"
local upper = zucchini.base_conversion.upper           -- "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
local english = zucchini.base_conversion.english       -- letters + punctuation

-- Convert between bases
local hex_string = "FF"
local decimal_string = zucchini.base_conversion.convert(hex_string, hexadecimal, decimal)
-- decimal_string = "255"

-- Create custom alphabet from sample text
local custom = zucchini.base_conversion.alphabet("Hello World")
-- Returns sorted unique characters: " HWdelor"
```

--------------------------------

### Variable-Length Quantity (VLQ) Serialization in Zucchini

Source: https://context7.com/mark-marks/zucchini/llms.txt

Shows how to use Zucchini's Variable-Length Quantity (VLQ) encoding for integers. VLQ is efficient for numbers with varying magnitudes, using fewer bytes for smaller numbers.

```luau
local cursor = zucchini.cursor()
local serdes = zucchini.vlq

-- Small numbers use fewer bytes
serdes.ser(cursor, 50)      -- Uses 1 byte
serdes.ser(cursor, 5000)    -- Uses 2 bytes
serdes.ser(cursor, 500000)  -- Uses 3 bytes

local large = serdes.des(cursor)  -- 500000
local medium = serdes.des(cursor) -- 5000
local small = serdes.des(cursor)  -- 50
```

--------------------------------

### Buffer Serialization

Source: https://context7.com/mark-marks/zucchini/llms.txt

Serialize raw binary buffers.

```APIDOC
## Buffer Serialization

### Description
Serialize raw binary buffers.

### Method
`zucchini.buffer.ser(cursor, buffer)` and `zucchini.buffer.des(cursor)` for dynamic length.
`zucchini.buffer { length }.ser(cursor, buffer)` and `zucchini.buffer { length }.des(cursor)` for fixed length.

### Endpoint
N/A (Library function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```luau
local zucchini = require("zucchini")
local cursor = zucchini.cursor()

-- Dynamic length buffer
local buf = buffer.create(8)
buffer.writeu32(buf, 0, 12345678)

zucchini.buffer.ser(cursor, buf)
local result = zucchini.buffer.des(cursor)
print(buffer.readu32(result, 0)) -- 12345678

-- Fixed length buffer
local fixed_buf_serdes = zucchini.buffer { 4 }
fixed_buf_serdes.ser(cursor, buf)
```

### Response
#### Success Response (200)
- **buffer** (buffer) - The deserialized buffer value.

#### Response Example
```json
{
  "example": "binary buffer data"
}
```
```

--------------------------------

### String Serialization

Source: https://context7.com/mark-marks/zucchini/llms.txt

Dynamic or fixed-length string encoding.

```APIDOC
## String Serialization

### Description
Dynamic or fixed-length string encoding.

### Method
`zucchini.string.ser(cursor, value)` and `zucchini.string.des(cursor)` for dynamic length.
`zucchini.string { length }.ser(cursor, value)` and `zucchini.string { length }.des(cursor)` for fixed length.

### Endpoint
N/A (Library function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```luau
local zucchini = require("zucchini")
local cursor = zucchini.cursor()

-- Dynamic length (length prefix + string data)
local dynamic_string = zucchini.string
dynamic_string.ser(cursor, "Hello, World!")
local str = dynamic_string.des(cursor) -- "Hello, World!"

-- Fixed length (no length prefix, exact bytes)
local fixed_string = zucchini.string { 13 }
fixed_string.ser(cursor, "Hello, World!")
local fixed_str = fixed_string.des(cursor) -- "Hello, World!"
```

### Response
#### Success Response (200)
- **string** (string) - The deserialized string value.

#### Response Example
```json
{
  "example": "Hello, World!"
}
```
```

--------------------------------

### Serialize/Deserialize Booleans with Zucchini

Source: https://context7.com/mark-marks/zucchini/llms.txt

Shows how to serialize single or multiple boolean values using Zucchini's boolean serializer. Multiple booleans can be packed efficiently into a single byte. Deserialization returns values in reverse order.

```luau
local zucchini = require("zucchini")
local serdes = zucchini.boolean

-- Serialize single boolean
serdes.ser(cursor, true)

-- Serialize multiple booleans (up to 8 packed into one byte)
serdes.ser(cursor, false, true, true, false, true, false, false, true)

-- Deserialize returns values in reverse order (stack-based)
local b1, b2, b3, b4, b5, b6, b7, b8 = serdes.des(cursor)
-- b1=false, b2=true, b3=true, b4=false, b5=true, b6=false, b7=false, b8=true

local single = serdes.des(cursor)
-- single = true
```

--------------------------------

### Define and Serialize/Deserialize Zucchini Record

Source: https://github.com/mark-marks/zucchini/blob/main/README.md

This snippet shows how to define a data record using Zucchini's syntax, including nested structures like arrays and maps. It then demonstrates serializing and deserializing an instance of this record using a Zucchini cursor.

```luau
local player_serdes = zucchini.record {
    position = zucchini.vector,
    health = zucchini.uint8,
    name = zucchini.string,
    poisoned = zucchini.boolean,
    items = zucchini.array {
        zucchini.record {
            count = zucchini.vlq,
            name = zucchini.string,
        },
    },
    inns = zucchini.map { [zucchini.string] = zucchini.boolean },
    equipped = zucchini.opt { zucchini.string },
}

local player = {
    position = vector.create(287.3855, -13486.3),
    health = 9,
    name = "Cedrick",
    poisoned = true,
    grappled = true,
    concious = false,
    items = {
        { name = "Lantern", count = 2 },
        { name = "Waterskin", count = 1 },
        { name = "Map", count = 4 },
    },
    inns = {
        ["The Copper Cauldron"] = true,
        Infirmary = true,
        ["His Recess"] = true,
    },
    equipped = nil,
}

local cursor = zucchini.cursor()
serdes.ser(cursor, player)

local player2 = serdes.des(cursor) -- Entirely equal to `player`, type and structure wise
```

--------------------------------

### Floating-Point Serialization

Source: https://context7.com/mark-marks/zucchini/llms.txt

32-bit and 64-bit floating-point numbers.

```APIDOC
## Floating-Point Serialization

### Description
32-bit and 64-bit floating-point numbers.

### Method
`zucchini.f32.ser(cursor, value)` and `zucchini.f32.des(cursor)`
`zucchini.f64.ser(cursor, value)` and `zucchini.f64.des(cursor)`

### Endpoint
N/A (Library function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```luau
local zucchini = require("zucchini")
local cursor = zucchini.cursor()

-- 32-bit float (4 bytes)
zucchini.f32.ser(cursor, 3.14159)
local pi_32 = zucchini.f32.des(cursor)

-- 64-bit float (8 bytes, higher precision)
zucchini.f64.ser(cursor, 2.718281828459045)
local e = zucchini.f64.des(cursor)
```

### Response
#### Success Response (200)
- **float** (number) - The deserialized floating-point value.

#### Response Example
```json
{
  "example": 3.14159
}
```
```

--------------------------------

### Serialize Dynamic/Unknown Types with Zucchini

Source: https://context7.com/mark-marks/zucchini/llms.txt

Serializes arbitrary Luau data without a predefined schema. This is useful for data where the structure is not known beforehand or can vary significantly. It handles nested tables, numbers, strings, booleans, and vectors.

```luau
local cursor = zucchini.cursor()

local my_data = {
    this = "is some random data",
    which = {
        you = {
            do_something = "not know anything about",
        },
        some_number = 1234,
    },
    and_it_works = "!",
    catch_them_all = nil,
    and_more = vector.create(12, 64, 0),
}

zucchini.unknown.ser(cursor, my_data)
local restored = zucchini.unknown.des(cursor)
-- restored is identical to my_data
```

--------------------------------

### Serialize Luau Vectors with Zucchini

Source: https://context7.com/mark-marks/zucchini/llms.txt

Serializes Luau native 3D vectors. Supports default precision (f32 for each component) and custom precision using specified types like uint8.

```luau
local cursor = zucchini.cursor()

-- Default precision (f32 for each component)
local vec = vector.create(3.14, 4.13, 1.34)
zucchini.vector.ser(cursor, vec)
local result = zucchini.vector.des(cursor) -- vector(3.14, 4.13, 1.34)

-- Custom precision (uint8 for each component)
local low_precision = zucchini.vector { zucchini.uint8 }
local int_vec = vector.create(1, 255, 128)
low_precision.ser(cursor, int_vec)
local int_result = low_precision.des(cursor)
```

--------------------------------

### Extend Dynamic Serialization with Custom Types in Luau

Source: https://context7.com/mark-marks/zucchini/llms.txt

Add custom type support to the dynamic serializer by defining and registering a custom serializer for your specific data type. This allows Zucchini to handle user-defined structures efficiently.

```luau
local zucchini = require("zucchini")

-- Define a custom serializer for your type
local my_custom_serdes = {
    ser = function(cursor, value)
        -- Serialize your custom type
        zucchini.string.ser(cursor, value.id)
        zucchini.f32.ser(cursor, value.timestamp)
    end,
    des = function(cursor)
        local timestamp = zucchini.f32.des(cursor)
        local id = zucchini.string.des(cursor)
        return { id = id, timestamp = timestamp }
    end,
}

-- Register the type (only works for typeof() distinguishable types)
zucchini.extend_internal(my_custom_serdes, "MyCustomType")
```

--------------------------------

### Integer Serialization

Source: https://context7.com/mark-marks/zucchini/llms.txt

Fixed-width unsigned and signed integers from 8 to 64 bits.

```APIDOC
## Integer Serialization

### Description
Fixed-width unsigned and signed integers from 8 to 64 bits.

### Method
`zucchini.[uint|int][8|16|24|32|40|48|56|64].ser(cursor, value)` and `zucchini.[uint|int][8|16|24|32|40|48|56|64].des(cursor)`

### Endpoint
N/A (Library function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```luau
local zucchini = require("zucchini")
local cursor = zucchini.cursor()

-- Unsigned integers
zucchini.uint8.ser(cursor, 255)        -- 1 byte (0-255)
zucchini.uint16.ser(cursor, 65535)     -- 2 bytes (0-65535)
zucchini.uint24.ser(cursor, 16777215)  -- 3 bytes
zucchini.uint32.ser(cursor, 4294967295) -- 4 bytes
zucchini.uint40.ser(cursor, 1099511627775) -- 5 bytes
zucchini.uint48.ser(cursor, 281474976710655) -- 6 bytes
zucchini.uint56.ser(cursor, 72057594037927935) -- 7 bytes
zucchini.uint64.ser(cursor, 9007199254740991) -- 8 bytes

-- Signed integers
zucchini.int8.ser(cursor, -128)        -- 1 byte (-128 to 127)
zucchini.int16.ser(cursor, -32768)     -- 2 bytes
zucchini.int24.ser(cursor, -8388608)   -- 3 bytes
zucchini.int32.ser(cursor, -2147483648) -- 4 bytes

-- Deserialize
local value = zucchini.uint8.des(cursor)
```

### Response
#### Success Response (200)
- **integer** (number) - The deserialized integer value.

#### Response Example
```json
{
  "example": 255
}
```
```

--------------------------------

### Cursor Creation

Source: https://context7.com/mark-marks/zucchini/llms.txt

The cursor is the fundamental structure for reading and writing serialized data. It manages a buffer and position for all serialization operations.

```APIDOC
## Cursor Creation

### Description
The cursor is the fundamental structure for reading and writing serialized data. It manages a buffer and position for all serialization operations.

### Method
`zucchini.cursor()` or `zucchini.cursor_from_buffer(buffer)`

### Endpoint
N/A (Library function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```luau
local zucchini = require("zucchini")

-- Create a new cursor with default buffer size (8 bytes, auto-resizes)
local cursor = zucchini.cursor()

-- Create a cursor from an existing buffer (for deserialization)
local existing_buffer = buffer.create(64)
local cursor_from_buf = zucchini.cursor_from_buffer(existing_buffer)
```

### Response
#### Success Response (200)
- **cursor** (table) - A Zucchini cursor object.

#### Response Example
```json
{
  "example": "cursor object"
}
```
```

--------------------------------

### Variable-Length Quantity (VLQ) Serialization

Source: https://context7.com/mark-marks/zucchini/llms.txt

Efficiently encode integers that vary widely in magnitude using 1-8 bytes.

```APIDOC
## Variable-Length Quantity (VLQ) Serialization

### Description
Efficiently encode integers that vary widely in magnitude using 1-8 bytes.

### Method
`zucchini.vlq.ser(cursor, value)` and `zucchini.vlq.des(cursor)`

### Endpoint
N/A (Library function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```luau
local zucchini = require("zucchini")
local serdes = zucchini.vlq
local cursor = zucchini.cursor()

-- Small numbers use fewer bytes
serdes.ser(cursor, 50)      -- Uses 1 byte
serdes.ser(cursor, 5000)    -- Uses 2 bytes
serdes.ser(cursor, 500000)  -- Uses 3 bytes

local large = serdes.des(cursor)  -- 500000
local medium = serdes.des(cursor) -- 5000
local small = serdes.des(cursor)  -- 50
```

### Response
#### Success Response (200)
- **vlq** (number) - The deserialized VLQ integer value.

#### Response Example
```json
{
  "example": 500000
}
```
```

--------------------------------

### Serialize Arrays with Zucchini

Source: https://context7.com/mark-marks/zucchini/llms.txt

Serializes lists of homogeneous elements. Supports dynamic length arrays (with length prefix) and fixed length arrays (without length prefix). Can serialize arrays of complex types like vectors.

```luau
local cursor = zucchini.cursor()

-- Dynamic length array
local dynamic_array = zucchini.array { zucchini.uint8 }
dynamic_array.ser(cursor, { 1, 2, 3, 4, 5, 6 })
local arr = dynamic_array.des(cursor) -- { 1, 2, 3, 4, 5, 6 }

-- Fixed length array (no length prefix)
local fixed_array = zucchini.array { zucchini.uint8, 4 }
fixed_array.ser(cursor, { 10, 20, 30, 40 })
local fixed_arr = fixed_array.des(cursor) -- { 10, 20, 30, 40 }

-- Array of complex types
local vector_array = zucchini.array { zucchini.vector }
vector_array.ser(cursor, {
    vector.create(1, 2, 3),
    vector.create(4, 5, 6),
})
```

--------------------------------

### Boolean Serialization

Source: https://context7.com/mark-marks/zucchini/llms.txt

Serialize boolean values efficiently. Multiple booleans can be packed into a single byte.

```APIDOC
## Boolean Serialization

### Description
Serialize boolean values efficiently. Multiple booleans can be packed into a single byte.

### Method
`zucchini.boolean.ser(cursor, ...)` and `zucchini.boolean.des(cursor)`

### Endpoint
N/A (Library function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```luau
local zucchini = require("zucchini")
local serdes = zucchini.boolean

local cursor = zucchini.cursor()

-- Serialize single boolean
serdes.ser(cursor, true)

-- Serialize multiple booleans (up to 8 packed into one byte)
serdes.ser(cursor, false, true, true, false, true, false, false, true)

-- Deserialize returns values in reverse order (stack-based)
local b1, b2, b3, b4, b5, b6, b7, b8 = serdes.des(cursor)
-- b1=false, b2=true, b3=true, b4=false, b5=true, b6=false, b7=false, b8=true

local single = serdes.des(cursor)
-- single = true
```

### Response
#### Success Response (200)
- **boolean** (boolean) - The deserialized boolean value(s).

#### Response Example
```json
{
  "example": "true or false"
}
```
```

--------------------------------

### Handle Optional Values with Zucchini

Source: https://context7.com/mark-marks/zucchini/llms.txt

Serializes and deserializes optional values (nil or a specific type). This is useful for fields that may or may not be present. It wraps a base serializer to add nil handling.

```luau
local cursor = zucchini.cursor()

-- Optional uint8 (can be nil or a number)
local opt_number = zucchini.opt { zucchini.uint8 }

opt_number.ser(cursor, nil)
opt_number.ser(cursor, 42)

local value1 = opt_number.des(cursor) -- 42
local value2 = opt_number.des(cursor) -- nil
```

--------------------------------

### Encode Literal Values with Zucchini

Source: https://context7.com/mark-marks/zucchini/llms.txt

Efficiently encodes specific constant values. This is useful for representing a fixed set of states or options. It takes a list of allowed string values.

```luau
local cursor = zucchini.cursor()

-- Define allowed literal values
local status = zucchini.literal { "active", "inactive", "pending" }

status.ser(cursor, "active")
local result = status.des(cursor) -- "active"
```

--------------------------------

### Extend Zucchini Dynamic Serdes with Custom Types

Source: https://github.com/mark-marks/zucchini/blob/main/README.md

This code snippet demonstrates how to extend Zucchini's dynamic serialization capabilities with custom data types. It defines a custom serdes object and registers it with Zucchini for use in dynamic serialization, provided the type is not already handled by Squash.

```luau
local my_serdes: zucchini.SerDes<MyDataType> = {
    ser = function(cursor, value)
        -- Some ser code
    end,
    des = function(cursor)
        -- Some des code
        return result
    end,
}

zucchini.extend_internal(my_serdes, "MyDataType") -- `MyDataType` is now available in dynamic serdes
```

--------------------------------

### Serialize Roblox Datatypes with Zucchini in Luau

Source: https://context7.com/mark-marks/zucchini/llms.txt

Utilize Zucchini's built-in support for serializing common Roblox-specific datatypes. This includes Vector3, Vector2, CFrame, Color3, UDim, UDim2, BrickColor, TweenInfo, DateTime, EnumItem, NumberRange, and ColorSequence.

```luau
local cursor = zucchini.cursor()

-- Vector3 with customizable precision
local vec3_serdes = zucchini.Vector3 -- default f32 precision
zucchini.Vector3.ser(cursor, Vector3.new(10, 20, 30))
local v3 = zucchini.Vector3.des(cursor)

-- Vector2
zucchini.Vector2.ser(cursor, Vector2.new(100, 200))

-- CFrame with position precision
zucchini.CFrame.ser(cursor, CFrame.new(10, 20, 30) * CFrame.Angles(0, math.pi/4, 0))

-- Color3 (RGB packed into 3 bytes)
zucchini.Color3.ser(cursor, Color3.fromRGB(255, 128, 64))

-- UDim and UDim2
zucchini.UDim.ser(cursor, UDim.new(0.5, 100))
zucchini.UDim2.ser(cursor, UDim2.new(0.5, 0, 1, -50))

-- BrickColor
zucchini.BrickColor.ser(cursor, BrickColor.new("Bright red"))

-- TweenInfo
zucchini.TweenInfo.ser(cursor, TweenInfo.new(1, Enum.EasingStyle.Quad, Enum.EasingDirection.Out))

-- DateTime
zucchini.DateTime.ser(cursor, DateTime.now())

-- EnumItem (requires specifying the Enum)
local material_serdes = zucchini.EnumItem(Enum.Material)
material_serdes.ser(cursor, Enum.Material.Plastic)

-- NumberRange
zucchini.NumberRange.ser(cursor, NumberRange.new(0, 100))

-- ColorSequence
zucchini.ColorSequence.ser(cursor, ColorSequence.new({
    ColorSequenceKeypoint.new(0, Color3.new(1, 0, 0)),
    ColorSequenceKeypoint.new(1, Color3.new(0, 0, 1)),
}))
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.