@f0rbit/corpus 0.1.0

package/README.md

@@ -0,0 +1,49 @@
+# corpus
+
+a functional snapshotting library for typescript. store versioned data with lineage tracking, content deduplication, and multiple backend support (memory, file, cloudflare d1/r2).
+
+## install
+
+```bash
+bun add corpus
+```
+
+## usage
+
+```typescript
+import { z } from 'zod'
+import { create_corpus, create_memory_backend, define_store, json_codec } from 'corpus'
+
+const TimelineSchema = z.object({
+  items: z.array(z.object({ id: z.string(), text: z.string() })),
+})
+
+const corpus = create_corpus()
+  .with_backend(create_memory_backend())
+  .with_store(define_store('timelines', json_codec(TimelineSchema)))
+  .build()
+
+// typed store access - version is auto-generated
+const result = await corpus.stores.timelines.put({ 
+  items: [{ id: '1', text: 'hello' }] 
+})
+
+if (result.ok) {
+  console.log('saved:', result.value.content_hash)
+}
+```
+
+## todo
+
+- [ ] add gzip compression codec wrapper for large json blobs
+- [ ] add encryption codec wrapper for sensitive data at rest
+- [ ] implement ttl/expiration support with auto-cleanup
+- [ ] add batch operations (put_many, get_many) for bulk imports
+- [ ] create drizzle migration files for d1 schema setup
+- [ ] add diff(v1, v2) function for comparing json snapshots
+- [ ] implement data compaction (merge old versions)
+- [ ] add rate limiting awareness for cloudflare api limits
+- [ ] create test utilities module with helpers (create_test_corpus, seed_test_data)
+- [ ] add signed url support for direct r2 access to large files
+- [ ] implement garbage collection for orphaned data blobs
+- [ ] add retry logic with exponential backoff for network failures

package/dist/backend/cloudflare.d.ts

@@ -0,0 +1,23 @@
+import type { Backend, EventHandler } from '../types';
+type D1Database = {
+    prepare: (sql: string) => unknown;
+};
+type R2Bucket = {
+    get: (key: string) => Promise<{
+        body: ReadableStream<Uint8Array>;
+        arrayBuffer: () => Promise<ArrayBuffer>;
+    } | null>;
+    put: (key: string, data: ReadableStream<Uint8Array> | Uint8Array) => Promise<void>;
+    delete: (key: string) => Promise<void>;
+    head: (key: string) => Promise<{
+        key: string;
+    } | null>;
+};
+export type CloudflareBackendConfig = {
+    d1: D1Database;
+    r2: R2Bucket;
+    on_event?: EventHandler;
+};
+export declare function create_cloudflare_backend(config: CloudflareBackendConfig): Backend;
+export {};
+//# sourceMappingURL=cloudflare.d.ts.map

package/dist/backend/cloudflare.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloudflare.d.ts","sourceRoot":"","sources":["../../backend/cloudflare.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAwF,YAAY,EAAE,MAAM,UAAU,CAAA;AAI3I,KAAK,UAAU,GAAG;IAAE,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAA;CAAE,CAAA;AACvD,KAAK,QAAQ,GAAG;IACd,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;QAAE,IAAI,EAAE,cAAc,CAAC,UAAU,CAAC,CAAC;QAAC,WAAW,EAAE,MAAM,OAAO,CAAC,WAAW,CAAC,CAAA;KAAE,GAAG,IAAI,CAAC,CAAA;IACnH,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,CAAC,UAAU,CAAC,GAAG,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAClF,MAAM,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IACtC,IAAI,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC,CAAA;CACvD,CAAA;AAED,MAAM,MAAM,uBAAuB,GAAG;IACpC,EAAE,EAAE,UAAU,CAAA;IACd,EAAE,EAAE,QAAQ,CAAA;IACZ,QAAQ,CAAC,EAAE,YAAY,CAAA;CACxB,CAAA;AAED,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,uBAAuB,GAAG,OAAO,CA8PlF"}

package/dist/backend/cloudflare.js

@@ -0,0 +1,226 @@
+import { eq, and, desc, lt, gt, like, sql } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/d1';
+import { ok, err } from '../types';
+import { corpus_snapshots } from '../schema';
+export function create_cloudflare_backend(config) {
+    const db = drizzle(config.d1);
+    const { r2, on_event } = config;
+    function emit(event) {
+        on_event?.(event);
+    }
+    function row_to_meta(row) {
+        return {
+            store_id: row.store_id,
+            version: row.version,
+            parents: JSON.parse(row.parents),
+            created_at: new Date(row.created_at),
+            invoked_at: row.invoked_at ? new Date(row.invoked_at) : undefined,
+            content_hash: row.content_hash,
+            content_type: row.content_type,
+            size_bytes: row.size_bytes,
+            data_key: row.data_key,
+            tags: row.tags ? JSON.parse(row.tags) : undefined,
+        };
+    }
+    const metadata = {
+        async get(store_id, version) {
+            try {
+                const rows = await db
+                    .select()
+                    .from(corpus_snapshots)
+                    .where(and(eq(corpus_snapshots.store_id, store_id), eq(corpus_snapshots.version, version)))
+                    .limit(1);
+                const row = rows[0];
+                emit({ type: 'meta_get', store_id, version, found: !!row });
+                if (!row) {
+                    return err({ kind: 'not_found', store_id, version });
+                }
+                return ok(row_to_meta(row));
+            }
+            catch (cause) {
+                const error = { kind: 'storage_error', cause: cause, operation: 'metadata.get' };
+                emit({ type: 'error', error });
+                return err(error);
+            }
+        },
+        async put(meta) {
+            try {
+                await db
+                    .insert(corpus_snapshots)
+                    .values({
+                    store_id: meta.store_id,
+                    version: meta.version,
+                    parents: JSON.stringify(meta.parents),
+                    created_at: meta.created_at.toISOString(),
+                    invoked_at: meta.invoked_at?.toISOString() ?? null,
+                    content_hash: meta.content_hash,
+                    content_type: meta.content_type,
+                    size_bytes: meta.size_bytes,
+                    data_key: meta.data_key,
+                    tags: meta.tags ? JSON.stringify(meta.tags) : null,
+                })
+                    .onConflictDoUpdate({
+                    target: [corpus_snapshots.store_id, corpus_snapshots.version],
+                    set: {
+                        parents: JSON.stringify(meta.parents),
+                        created_at: meta.created_at.toISOString(),
+                        invoked_at: meta.invoked_at?.toISOString() ?? null,
+                        content_hash: meta.content_hash,
+                        content_type: meta.content_type,
+                        size_bytes: meta.size_bytes,
+                        data_key: meta.data_key,
+                        tags: meta.tags ? JSON.stringify(meta.tags) : null,
+                    },
+                });
+                emit({ type: 'meta_put', store_id: meta.store_id, version: meta.version });
+                return ok(undefined);
+            }
+            catch (cause) {
+                const error = { kind: 'storage_error', cause: cause, operation: 'metadata.put' };
+                emit({ type: 'error', error });
+                return err(error);
+            }
+        },
+        async delete(store_id, version) {
+            try {
+                await db
+                    .delete(corpus_snapshots)
+                    .where(and(eq(corpus_snapshots.store_id, store_id), eq(corpus_snapshots.version, version)));
+                emit({ type: 'meta_delete', store_id, version });
+                return ok(undefined);
+            }
+            catch (cause) {
+                const error = { kind: 'storage_error', cause: cause, operation: 'metadata.delete' };
+                emit({ type: 'error', error });
+                return err(error);
+            }
+        },
+        async *list(store_id, opts) {
+            const conditions = [like(corpus_snapshots.store_id, `${store_id}%`)];
+            if (opts?.before) {
+                conditions.push(lt(corpus_snapshots.created_at, opts.before.toISOString()));
+            }
+            if (opts?.after) {
+                conditions.push(gt(corpus_snapshots.created_at, opts.after.toISOString()));
+            }
+            let query = db
+                .select()
+                .from(corpus_snapshots)
+                .where(and(...conditions))
+                .orderBy(desc(corpus_snapshots.created_at));
+            if (opts?.limit) {
+                query = query.limit(opts.limit);
+            }
+            const rows = await query;
+            let count = 0;
+            for (const row of rows) {
+                const meta = row_to_meta(row);
+                if (opts?.tags?.length && !opts.tags.some(t => meta.tags?.includes(t))) {
+                    continue;
+                }
+                yield meta;
+                count++;
+            }
+            emit({ type: 'meta_list', store_id, count });
+        },
+        async get_latest(store_id) {
+            try {
+                const rows = await db
+                    .select()
+                    .from(corpus_snapshots)
+                    .where(eq(corpus_snapshots.store_id, store_id))
+                    .orderBy(desc(corpus_snapshots.created_at))
+                    .limit(1);
+                const row = rows[0];
+                if (!row) {
+                    return err({ kind: 'not_found', store_id, version: 'latest' });
+                }
+                return ok(row_to_meta(row));
+            }
+            catch (cause) {
+                const error = { kind: 'storage_error', cause: cause, operation: 'metadata.get_latest' };
+                emit({ type: 'error', error });
+                return err(error);
+            }
+        },
+        async *get_children(parent_store_id, parent_version) {
+            const rows = await db
+                .select()
+                .from(corpus_snapshots)
+                .where(sql `EXISTS (
+            SELECT 1 FROM json_each(${corpus_snapshots.parents}) 
+            WHERE json_extract(value, '$.store_id') = ${parent_store_id}
+              AND json_extract(value, '$.version') = ${parent_version}
+          )`);
+            for (const row of rows) {
+                yield row_to_meta(row);
+            }
+        },
+        async find_by_hash(store_id, content_hash) {
+            try {
+                const rows = await db
+                    .select()
+                    .from(corpus_snapshots)
+                    .where(and(eq(corpus_snapshots.store_id, store_id), eq(corpus_snapshots.content_hash, content_hash)))
+                    .limit(1);
+                const row = rows[0];
+                return row ? row_to_meta(row) : null;
+            }
+            catch {
+                return null;
+            }
+        },
+    };
+    const data = {
+        async get(data_key) {
+            try {
+                const object = await r2.get(data_key);
+                emit({ type: 'data_get', store_id: data_key.split('/')[0] ?? data_key, version: data_key, found: !!object });
+                if (!object) {
+                    return err({ kind: 'not_found', store_id: data_key, version: '' });
+                }
+                return ok({
+                    stream: () => object.body,
+                    bytes: async () => new Uint8Array(await object.arrayBuffer()),
+                });
+            }
+            catch (cause) {
+                const error = { kind: 'storage_error', cause: cause, operation: 'data.get' };
+                emit({ type: 'error', error });
+                return err(error);
+            }
+        },
+        async put(data_key, input) {
+            try {
+                await r2.put(data_key, input);
+                return ok(undefined);
+            }
+            catch (cause) {
+                const error = { kind: 'storage_error', cause: cause, operation: 'data.put' };
+                emit({ type: 'error', error });
+                return err(error);
+            }
+        },
+        async delete(data_key) {
+            try {
+                await r2.delete(data_key);
+                return ok(undefined);
+            }
+            catch (cause) {
+                const error = { kind: 'storage_error', cause: cause, operation: 'data.delete' };
+                emit({ type: 'error', error });
+                return err(error);
+            }
+        },
+        async exists(data_key) {
+            try {
+                const head = await r2.head(data_key);
+                return head !== null;
+            }
+            catch {
+                return false;
+            }
+        },
+    };
+    return { metadata, data, on_event };
+}

package/dist/backend/file.d.ts

@@ -0,0 +1,7 @@
+import type { Backend, EventHandler } from '../types';
+export type FileBackendConfig = {
+    base_path: string;
+    on_event?: EventHandler;
+};
+export declare function create_file_backend(config: FileBackendConfig): Backend;
+//# sourceMappingURL=file.d.ts.map

package/dist/backend/file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../backend/file.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAwF,YAAY,EAAE,MAAM,UAAU,CAAA;AAK3I,MAAM,MAAM,iBAAiB,GAAG;IAC9B,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,YAAY,CAAA;CACxB,CAAA;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAqMtE"}

package/dist/backend/file.js

@@ -0,0 +1,194 @@
+import { ok, err } from '../types';
+import { mkdir, unlink, readdir } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+export function create_file_backend(config) {
+    const { base_path, on_event } = config;
+    function emit(event) {
+        on_event?.(event);
+    }
+    function meta_path(store_id) {
+        return join(base_path, store_id, '_meta.json');
+    }
+    function data_path(data_key) {
+        return join(base_path, '_data', `${data_key.replace(/\//g, '_')}.bin`);
+    }
+    async function read_store_meta(store_id) {
+        const path = meta_path(store_id);
+        const file = Bun.file(path);
+        if (!await file.exists())
+            return new Map();
+        try {
+            const content = await file.text();
+            const entries = JSON.parse(content, (key, value) => {
+                if (key === 'created_at' || key === 'invoked_at') {
+                    return value ? new Date(value) : value;
+                }
+                return value;
+            });
+            return new Map(entries);
+        }
+        catch {
+            return new Map();
+        }
+    }
+    async function write_store_meta(store_id, meta_map) {
+        const path = meta_path(store_id);
+        await mkdir(dirname(path), { recursive: true });
+        const entries = Array.from(meta_map.entries());
+        await Bun.write(path, JSON.stringify(entries));
+    }
+    const metadata = {
+        async get(store_id, version) {
+            const store_meta = await read_store_meta(store_id);
+            const meta = store_meta.get(version);
+            emit({ type: 'meta_get', store_id, version, found: !!meta });
+            if (!meta) {
+                return err({ kind: 'not_found', store_id, version });
+            }
+            return ok(meta);
+        },
+        async put(meta) {
+            const store_meta = await read_store_meta(meta.store_id);
+            store_meta.set(meta.version, meta);
+            await write_store_meta(meta.store_id, store_meta);
+            emit({ type: 'meta_put', store_id: meta.store_id, version: meta.version });
+            return ok(undefined);
+        },
+        async delete(store_id, version) {
+            const store_meta = await read_store_meta(store_id);
+            store_meta.delete(version);
+            await write_store_meta(store_id, store_meta);
+            emit({ type: 'meta_delete', store_id, version });
+            return ok(undefined);
+        },
+        async *list(store_id, opts) {
+            const store_meta = await read_store_meta(store_id);
+            const matches = Array.from(store_meta.values())
+                .filter(meta => {
+                if (opts?.before && meta.created_at >= opts.before)
+                    return false;
+                if (opts?.after && meta.created_at <= opts.after)
+                    return false;
+                if (opts?.tags?.length && !opts.tags.some(t => meta.tags?.includes(t)))
+                    return false;
+                return true;
+            })
+                .sort((a, b) => b.created_at.getTime() - a.created_at.getTime());
+            const limit = opts?.limit ?? Infinity;
+            let count = 0;
+            for (const meta of matches.slice(0, limit)) {
+                yield meta;
+                count++;
+            }
+            emit({ type: 'meta_list', store_id, count });
+        },
+        async get_latest(store_id) {
+            const store_meta = await read_store_meta(store_id);
+            let latest = null;
+            for (const meta of store_meta.values()) {
+                if (!latest || meta.created_at > latest.created_at) {
+                    latest = meta;
+                }
+            }
+            if (!latest) {
+                return err({ kind: 'not_found', store_id, version: 'latest' });
+            }
+            return ok(latest);
+        },
+        async *get_children(parent_store_id, parent_version) {
+            try {
+                const entries = await readdir(base_path, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (!entry.isDirectory() || entry.name.startsWith('_'))
+                        continue;
+                    const store_meta = await read_store_meta(entry.name);
+                    for (const meta of store_meta.values()) {
+                        const is_child = meta.parents.some(p => p.store_id === parent_store_id && p.version === parent_version);
+                        if (is_child)
+                            yield meta;
+                    }
+                }
+            }
+            catch {
+            }
+        },
+        async find_by_hash(store_id, content_hash) {
+            const store_meta = await read_store_meta(store_id);
+            for (const meta of store_meta.values()) {
+                if (meta.content_hash === content_hash) {
+                    return meta;
+                }
+            }
+            return null;
+        },
+    };
+    const data = {
+        async get(data_key) {
+            const path = data_path(data_key);
+            const file = Bun.file(path);
+            const found = await file.exists();
+            emit({ type: 'data_get', store_id: data_key.split('/')[0] ?? data_key, version: data_key, found });
+            if (!found) {
+                return err({ kind: 'not_found', store_id: data_key, version: '' });
+            }
+            return ok({
+                stream: () => file.stream(),
+                bytes: async () => new Uint8Array(await file.arrayBuffer()),
+            });
+        },
+        async put(data_key, input) {
+            const path = data_path(data_key);
+            await mkdir(dirname(path), { recursive: true });
+            try {
+                if (input instanceof Uint8Array) {
+                    await Bun.write(path, input);
+                }
+                else {
+                    const chunks = [];
+                    const reader = input.getReader();
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        chunks.push(value);
+                    }
+                    const bytes = concat_bytes(chunks);
+                    await Bun.write(path, bytes);
+                }
+                return ok(undefined);
+            }
+            catch (cause) {
+                return err({ kind: 'storage_error', cause: cause, operation: 'put' });
+            }
+        },
+        async delete(data_key) {
+            const path = data_path(data_key);
+            try {
+                const file = Bun.file(path);
+                if (await file.exists()) {
+                    await unlink(path);
+                }
+                return ok(undefined);
+            }
+            catch (cause) {
+                return err({ kind: 'storage_error', cause: cause, operation: 'delete' });
+            }
+        },
+        async exists(data_key) {
+            const path = data_path(data_key);
+            const file = Bun.file(path);
+            return file.exists();
+        },
+    };
+    return { metadata, data, on_event };
+}
+function concat_bytes(chunks) {
+    const total = chunks.reduce((sum, c) => sum + c.length, 0);
+    const result = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        result.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return result;
+}

package/dist/backend/memory.d.ts

@@ -0,0 +1,6 @@
+import type { Backend, EventHandler } from '../types';
+export type MemoryBackendOptions = {
+    on_event?: EventHandler;
+};
+export declare function create_memory_backend(options?: MemoryBackendOptions): Backend;
+//# sourceMappingURL=memory.d.ts.map

package/dist/backend/memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../backend/memory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAwF,YAAY,EAAE,MAAM,UAAU,CAAA;AAG3I,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,CAAC,EAAE,YAAY,CAAA;CACxB,CAAA;AAED,wBAAgB,qBAAqB,CAAC,OAAO,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAiJ7E"}

package/dist/backend/memory.js

@@ -0,0 +1,141 @@
+import { ok, err } from '../types';
+export function create_memory_backend(options) {
+    const meta_store = new Map();
+    const data_store = new Map();
+    const on_event = options?.on_event;
+    function emit(event) {
+        on_event?.(event);
+    }
+    function make_meta_key(store_id, version) {
+        return `${store_id}:${version}`;
+    }
+    const metadata = {
+        async get(store_id, version) {
+            const meta = meta_store.get(make_meta_key(store_id, version));
+            emit({ type: 'meta_get', store_id, version, found: !!meta });
+            if (!meta) {
+                return err({ kind: 'not_found', store_id, version });
+            }
+            return ok(meta);
+        },
+        async put(meta) {
+            meta_store.set(make_meta_key(meta.store_id, meta.version), meta);
+            emit({ type: 'meta_put', store_id: meta.store_id, version: meta.version });
+            return ok(undefined);
+        },
+        async delete(store_id, version) {
+            meta_store.delete(make_meta_key(store_id, version));
+            emit({ type: 'meta_delete', store_id, version });
+            return ok(undefined);
+        },
+        async *list(store_id, opts) {
+            const prefix = `${store_id}:`;
+            const matches = [];
+            for (const [key, meta] of meta_store) {
+                if (!key.startsWith(prefix))
+                    continue;
+                if (opts?.before && meta.created_at >= opts.before)
+                    continue;
+                if (opts?.after && meta.created_at <= opts.after)
+                    continue;
+                if (opts?.tags?.length && !opts.tags.some(t => meta.tags?.includes(t)))
+                    continue;
+                matches.push(meta);
+            }
+            matches.sort((a, b) => b.created_at.getTime() - a.created_at.getTime());
+            const limit = opts?.limit ?? Infinity;
+            let count = 0;
+            for (const match of matches.slice(0, limit)) {
+                yield match;
+                count++;
+            }
+            emit({ type: 'meta_list', store_id, count });
+        },
+        async get_latest(store_id) {
+            let latest = null;
+            const prefix = `${store_id}:`;
+            for (const [key, meta] of meta_store) {
+                if (!key.startsWith(prefix))
+                    continue;
+                if (!latest || meta.created_at > latest.created_at) {
+                    latest = meta;
+                }
+            }
+            if (!latest) {
+                return err({ kind: 'not_found', store_id, version: 'latest' });
+            }
+            return ok(latest);
+        },
+        async *get_children(parent_store_id, parent_version) {
+            for (const meta of meta_store.values()) {
+                const is_child = meta.parents.some(p => p.store_id === parent_store_id && p.version === parent_version);
+                if (is_child)
+                    yield meta;
+            }
+        },
+        async find_by_hash(store_id, content_hash) {
+            const prefix = `${store_id}:`;
+            for (const [key, meta] of meta_store) {
+                if (key.startsWith(prefix) && meta.content_hash === content_hash) {
+                    return meta;
+                }
+            }
+            return null;
+        },
+    };
+    const data = {
+        async get(data_key) {
+            const bytes = data_store.get(data_key);
+            emit({ type: 'data_get', store_id: data_key.split('/')[0] ?? data_key, version: data_key, found: !!bytes });
+            if (!bytes) {
+                return err({ kind: 'not_found', store_id: data_key, version: '' });
+            }
+            return ok({
+                stream: () => new ReadableStream({
+                    start(controller) {
+                        controller.enqueue(bytes);
+                        controller.close();
+                    }
+                }),
+                bytes: async () => bytes,
+            });
+        },
+        async put(data_key, input) {
+            let bytes;
+            if (input instanceof Uint8Array) {
+                bytes = input;
+            }
+            else {
+                const chunks = [];
+                const reader = input.getReader();
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    chunks.push(value);
+                }
+                bytes = concat_bytes(chunks);
+            }
+            data_store.set(data_key, bytes);
+            return ok(undefined);
+        },
+        async delete(data_key) {
+            data_store.delete(data_key);
+            return ok(undefined);
+        },
+        async exists(data_key) {
+            return data_store.has(data_key);
+        },
+    };
+    return { metadata, data, on_event };
+}
+function concat_bytes(chunks) {
+    const total = chunks.reduce((sum, c) => sum + c.length, 0);
+    const result = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        result.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return result;
+}

package/dist/codec.d.ts

@@ -0,0 +1,6 @@
+import type { ZodSchema } from "zod";
+import type { Codec } from "./types";
+export declare function json_codec<T>(schema: ZodSchema<T>): Codec<T>;
+export declare function text_codec(): Codec<string>;
+export declare function binary_codec(): Codec<Uint8Array>;
+//# sourceMappingURL=codec.d.ts.map

package/dist/codec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec.d.ts","sourceRoot":"","sources":["../codec.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,KAAK,CAAC;AACrC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAErC,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAM5D;AAED,wBAAgB,UAAU,IAAI,KAAK,CAAC,MAAM,CAAC,CAM1C;AAED,wBAAgB,YAAY,IAAI,KAAK,CAAC,UAAU,CAAC,CAMhD"}