@f0rbit/corpus 0.1.3 → 0.1.4

package/dist/backend/cloudflare.d.ts

@@ -1,3 +1,7 @@
+/**
+ * @module Backends
+ * @description Cloudflare Workers storage backend using D1 and R2.
+ */
 import type { Backend, EventHandler } from '../types';
 type D1Database = {
     prepare: (sql: string) => unknown;
@@ -18,6 +22,42 @@ export type CloudflareBackendConfig = {
     r2: R2Bucket;
     on_event?: EventHandler;
 };
+/**
+ * Creates a Cloudflare Workers storage backend using D1 and R2.
+ * @category Backends
+ * @group Storage Backends
+ *
+ * Uses D1 (SQLite) for metadata storage and R2 (object storage) for binary data.
+ * Requires running `CORPUS_MIGRATION_SQL` on the D1 database before first use.
+ *
+ * This backend is designed for production use in Cloudflare Workers environments,
+ * providing durable, globally distributed storage.
+ *
+ * @param config - Configuration with `d1` (D1 database), `r2` (R2 bucket), and optional `on_event` handler
+ * @returns A Backend instance using Cloudflare D1 + R2
+ *
+ * @example
+ * ```ts
+ * // In a Cloudflare Worker
+ * export default {
+ *   async fetch(request: Request, env: Env) {
+ *     const backend = create_cloudflare_backend({
+ *       d1: env.CORPUS_DB,
+ *       r2: env.CORPUS_BUCKET
+ *     })
+ *
+ *     const corpus = create_corpus()
+ *       .with_backend(backend)
+ *       .with_store(define_store('cache', json_codec(CacheSchema)))
+ *       .build()
+ *
+ *     // Use corpus...
+ *   }
+ * }
+ * ```
+ *
+ * @see CORPUS_MIGRATION_SQL for required database setup
+ */
 export declare function create_cloudflare_backend(config: CloudflareBackendConfig): Backend;
 export {};
 //# sourceMappingURL=cloudflare.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"cloudflare.d.ts","sourceRoot":"","sources":["../../backend/cloudflare.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,uBAAuB,GAAG,OAAO,CA8PlF"}

package/dist/backend/cloudflare.js

@@ -1,7 +1,47 @@
+/**
+ * @module Backends
+ * @description Cloudflare Workers storage backend using D1 and R2.
+ */
 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';
+/**
+ * Creates a Cloudflare Workers storage backend using D1 and R2.
+ * @category Backends
+ * @group Storage Backends
+ *
+ * Uses D1 (SQLite) for metadata storage and R2 (object storage) for binary data.
+ * Requires running `CORPUS_MIGRATION_SQL` on the D1 database before first use.
+ *
+ * This backend is designed for production use in Cloudflare Workers environments,
+ * providing durable, globally distributed storage.
+ *
+ * @param config - Configuration with `d1` (D1 database), `r2` (R2 bucket), and optional `on_event` handler
+ * @returns A Backend instance using Cloudflare D1 + R2
+ *
+ * @example
+ * ```ts
+ * // In a Cloudflare Worker
+ * export default {
+ *   async fetch(request: Request, env: Env) {
+ *     const backend = create_cloudflare_backend({
+ *       d1: env.CORPUS_DB,
+ *       r2: env.CORPUS_BUCKET
+ *     })
+ *
+ *     const corpus = create_corpus()
+ *       .with_backend(backend)
+ *       .with_store(define_store('cache', json_codec(CacheSchema)))
+ *       .build()
+ *
+ *     // Use corpus...
+ *   }
+ * }
+ * ```
+ *
+ * @see CORPUS_MIGRATION_SQL for required database setup
+ */
 export function create_cloudflare_backend(config) {
     const db = drizzle(config.d1);
     const { r2, on_event } = config;

package/dist/backend/file.d.ts

@@ -1,7 +1,42 @@
+/**
+ * @module Backends
+ * @description File-system storage backend for local persistence.
+ */
 import type { Backend, EventHandler } from '../types';
 export type FileBackendConfig = {
     base_path: string;
     on_event?: EventHandler;
 };
+/**
+ * Creates a file-system storage backend for local persistence.
+ * @category Backends
+ * @group Storage Backends
+ *
+ * Uses Bun's file APIs for efficient I/O. Metadata is stored as JSON files
+ * per store, and data is stored as binary files in a shared `_data` directory.
+ *
+ * Directory structure:
+ * ```
+ * base_path/
+ *   <store_id>/_meta.json     # Metadata for each store
+ *   _data/<store_id>_<hash>.bin  # Binary data files
+ * ```
+ *
+ * @param config - Configuration with `base_path` (root directory) and optional `on_event` handler
+ * @returns A Backend instance using file-system storage
+ *
+ * @example
+ * ```ts
+ * const backend = create_file_backend({
+ *   base_path: './data/corpus',
+ *   on_event: (e) => console.log(e.type)
+ * })
+ *
+ * const corpus = create_corpus()
+ *   .with_backend(backend)
+ *   .with_store(define_store('documents', json_codec(DocSchema)))
+ *   .build()
+ * ```
+ */
 export declare function create_file_backend(config: FileBackendConfig): Backend;
 //# sourceMappingURL=file.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../backend/file.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAqMtE"}

package/dist/backend/file.js

@@ -1,6 +1,41 @@
+/**
+ * @module Backends
+ * @description File-system storage backend for local persistence.
+ */
 import { ok, err } from '../types';
 import { mkdir, readdir } from 'node:fs/promises';
 import { join, dirname } from 'node:path';
+/**
+ * Creates a file-system storage backend for local persistence.
+ * @category Backends
+ * @group Storage Backends
+ *
+ * Uses Bun's file APIs for efficient I/O. Metadata is stored as JSON files
+ * per store, and data is stored as binary files in a shared `_data` directory.
+ *
+ * Directory structure:
+ * ```
+ * base_path/
+ *   <store_id>/_meta.json     # Metadata for each store
+ *   _data/<store_id>_<hash>.bin  # Binary data files
+ * ```
+ *
+ * @param config - Configuration with `base_path` (root directory) and optional `on_event` handler
+ * @returns A Backend instance using file-system storage
+ *
+ * @example
+ * ```ts
+ * const backend = create_file_backend({
+ *   base_path: './data/corpus',
+ *   on_event: (e) => console.log(e.type)
+ * })
+ *
+ * const corpus = create_corpus()
+ *   .with_backend(backend)
+ *   .with_store(define_store('documents', json_codec(DocSchema)))
+ *   .build()
+ * ```
+ */
 export function create_file_backend(config) {
     const { base_path, on_event } = config;
     function emit(event) {

package/dist/backend/layered.d.ts

@@ -1,8 +1,46 @@
+/**
+ * @module Backends
+ * @description Layered backend for caching and replication strategies.
+ */
 import type { Backend } from '../types';
 export type LayeredBackendOptions = {
     read: Backend[];
     write: Backend[];
     list_strategy?: 'merge' | 'first';
 };
+/**
+ * Creates a layered backend that combines multiple backends with read/write separation.
+ * @category Backends
+ * @group Composite Backends
+ *
+ * Read operations use fallback: tries each read backend in order until one succeeds.
+ * Write operations use fanout: writes to all write backends (fails if any fail).
+ *
+ * Common use cases:
+ * - **Caching**: Memory backend first for reads, file backend for persistence
+ * - **Replication**: Write to multiple backends for redundancy
+ * - **Migration**: Read from old + new backends, write only to new
+ *
+ * @param options - Configuration with `read` backends (tried in order), `write` backends (all receive writes), and optional `list_strategy` ('merge' or 'first')
+ * @returns A Backend that delegates to the configured backends
+ *
+ * @example
+ * ```ts
+ * // Caching layer: memory cache with file persistence
+ * const cache = create_memory_backend()
+ * const storage = create_file_backend({ base_path: './data' })
+ *
+ * const backend = create_layered_backend({
+ *   read: [cache, storage],   // Try cache first, fall back to disk
+ *   write: [cache, storage],  // Write to both
+ * })
+ *
+ * // Migration: read from old and new, write only to new
+ * const backend = create_layered_backend({
+ *   read: [newBackend, oldBackend],
+ *   write: [newBackend],
+ * })
+ * ```
+ */
 export declare function create_layered_backend(options: LayeredBackendOptions): Backend;
 //# sourceMappingURL=layered.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"layered.d.ts","sourceRoot":"","sources":["../../backend/layered.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAA6E,MAAM,UAAU,CAAA;AAGlH,MAAM,MAAM,qBAAqB,GAAG;IAClC,IAAI,EAAE,OAAO,EAAE,CAAA;IACf,KAAK,EAAE,OAAO,EAAE,CAAA;IAChB,aAAa,CAAC,EAAE,OAAO,GAAG,OAAO,CAAA;CAClC,CAAA;AAED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CA4I9E"}
+{"version":3,"file":"layered.d.ts","sourceRoot":"","sources":["../../backend/layered.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,OAAO,EAA6E,MAAM,UAAU,CAAA;AAGlH,MAAM,MAAM,qBAAqB,GAAG;IAClC,IAAI,EAAE,OAAO,EAAE,CAAA;IACf,KAAK,EAAE,OAAO,EAAE,CAAA;IAChB,aAAa,CAAC,EAAE,OAAO,GAAG,OAAO,CAAA;CAClC,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CA4I9E"}

package/dist/backend/layered.js

@@ -1,4 +1,42 @@
+/**
+ * @module Backends
+ * @description Layered backend for caching and replication strategies.
+ */
 import { ok, err } from '../types';
+/**
+ * Creates a layered backend that combines multiple backends with read/write separation.
+ * @category Backends
+ * @group Composite Backends
+ *
+ * Read operations use fallback: tries each read backend in order until one succeeds.
+ * Write operations use fanout: writes to all write backends (fails if any fail).
+ *
+ * Common use cases:
+ * - **Caching**: Memory backend first for reads, file backend for persistence
+ * - **Replication**: Write to multiple backends for redundancy
+ * - **Migration**: Read from old + new backends, write only to new
+ *
+ * @param options - Configuration with `read` backends (tried in order), `write` backends (all receive writes), and optional `list_strategy` ('merge' or 'first')
+ * @returns A Backend that delegates to the configured backends
+ *
+ * @example
+ * ```ts
+ * // Caching layer: memory cache with file persistence
+ * const cache = create_memory_backend()
+ * const storage = create_file_backend({ base_path: './data' })
+ *
+ * const backend = create_layered_backend({
+ *   read: [cache, storage],   // Try cache first, fall back to disk
+ *   write: [cache, storage],  // Write to both
+ * })
+ *
+ * // Migration: read from old and new, write only to new
+ * const backend = create_layered_backend({
+ *   read: [newBackend, oldBackend],
+ *   write: [newBackend],
+ * })
+ * ```
+ */
 export function create_layered_backend(options) {
     const { read, write, list_strategy = 'merge' } = options;
     const metadata = {

package/dist/backend/memory.d.ts

@@ -1,6 +1,36 @@
+/**
+ * @module Backends
+ * @description In-memory storage backend for testing and development.
+ */
 import type { Backend, EventHandler } from '../types';
 export type MemoryBackendOptions = {
     on_event?: EventHandler;
 };
+/**
+ * Creates an in-memory storage backend.
+ * @category Backends
+ * @group Storage Backends
+ *
+ * Ideal for testing, development, and ephemeral storage scenarios.
+ * All data is lost when the process ends.
+ *
+ * @param options - Optional configuration with `on_event` handler for observability
+ * @returns A Backend instance using in-memory storage
+ *
+ * @example
+ * ```ts
+ * // Basic usage for testing
+ * const backend = create_memory_backend()
+ * const corpus = create_corpus()
+ *   .with_backend(backend)
+ *   .with_store(define_store('test', text_codec()))
+ *   .build()
+ *
+ * // With event logging
+ * const backend = create_memory_backend({
+ *   on_event: (e) => console.log(`[${e.type}]`, e)
+ * })
+ * ```
+ */
 export declare function create_memory_backend(options?: MemoryBackendOptions): Backend;
 //# sourceMappingURL=memory.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../backend/memory.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAwF,YAAY,EAAE,MAAM,UAAU,CAAA;AAG3I,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,CAAC,EAAE,YAAY,CAAA;CACxB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAiJ7E"}

package/dist/backend/memory.js

@@ -1,4 +1,34 @@
+/**
+ * @module Backends
+ * @description In-memory storage backend for testing and development.
+ */
 import { ok, err } from '../types';
+/**
+ * Creates an in-memory storage backend.
+ * @category Backends
+ * @group Storage Backends
+ *
+ * Ideal for testing, development, and ephemeral storage scenarios.
+ * All data is lost when the process ends.
+ *
+ * @param options - Optional configuration with `on_event` handler for observability
+ * @returns A Backend instance using in-memory storage
+ *
+ * @example
+ * ```ts
+ * // Basic usage for testing
+ * const backend = create_memory_backend()
+ * const corpus = create_corpus()
+ *   .with_backend(backend)
+ *   .with_store(define_store('test', text_codec()))
+ *   .build()
+ *
+ * // With event logging
+ * const backend = create_memory_backend({
+ *   on_event: (e) => console.log(`[${e.type}]`, e)
+ * })
+ * ```
+ */
 export function create_memory_backend(options) {
     const meta_store = new Map();
     const data_store = new Map();

package/dist/backends.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Storage backend implementations for different environments.
+ * @module Backends
+ * @packageDocumentation
+ */
+export { create_memory_backend, type MemoryBackendOptions } from './backend/memory';
+export { create_file_backend, type FileBackendConfig } from './backend/file';
+export { create_cloudflare_backend, type CloudflareBackendConfig } from './backend/cloudflare';
+export { create_layered_backend, type LayeredBackendOptions } from './backend/layered';
+export type { Backend, MetadataClient, DataClient, DataHandle, EventHandler, CorpusEvent } from './types';
+//# sourceMappingURL=backends.d.ts.map

package/dist/backends.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backends.d.ts","sourceRoot":"","sources":["../backends.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,qBAAqB,EAAE,KAAK,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AACnF,OAAO,EAAE,mBAAmB,EAAE,KAAK,iBAAiB,EAAE,MAAM,gBAAgB,CAAA;AAC5E,OAAO,EAAE,yBAAyB,EAAE,KAAK,uBAAuB,EAAE,MAAM,sBAAsB,CAAA;AAC9F,OAAO,EAAE,sBAAsB,EAAE,KAAK,qBAAqB,EAAE,MAAM,mBAAmB,CAAA;AACtF,YAAY,EAAE,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,UAAU,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA"}

package/dist/backends.js

@@ -0,0 +1,9 @@
+/**
+ * Storage backend implementations for different environments.
+ * @module Backends
+ * @packageDocumentation
+ */
+export { create_memory_backend } from './backend/memory';
+export { create_file_backend } from './backend/file';
+export { create_cloudflare_backend } from './backend/cloudflare';
+export { create_layered_backend } from './backend/layered';

package/dist/cloudflare.d.ts

@@ -2,14 +2,11 @@
  * Cloudflare Workers compatible exports
  * This entry point excludes the file backend which uses Node.js APIs
  */
-export { create_corpus } from './corpus';
-export { create_store } from './store';
+export { create_corpus, create_store } from './corpus';
 export { create_memory_backend, type MemoryBackendOptions } from './backend/memory';
 export { create_cloudflare_backend, type CloudflareBackendConfig } from './backend/cloudflare';
-export { json_codec, text_codec, binary_codec } from './codec';
+export { json_codec, text_codec, binary_codec, compute_hash, generate_version } from './utils';
 export { corpus_snapshots, type CorpusSnapshotRow, type CorpusSnapshotInsert } from './schema';
-export { compute_hash } from './hash';
-export { generate_version } from './version';
 export type { ContentType, ParentRef, SnapshotMeta, Snapshot, DataHandle, MetadataClient, DataClient, ListOpts, Backend, Codec, Store, StoreDefinition, PutOpts, CorpusBuilder, Corpus, CorpusError, Result, CorpusEvent, EventHandler, } from './types';
 export { ok, err, define_store } from './types';
 //# sourceMappingURL=cloudflare.d.ts.map

package/dist/cloudflare.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cloudflare.d.ts","sourceRoot":"","sources":["../cloudflare.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAEtC,OAAO,EAAE,qBAAqB,EAAE,KAAK,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AACnF,OAAO,EAAE,yBAAyB,EAAE,KAAK,uBAAuB,EAAE,MAAM,sBAAsB,CAAA;AAE9F,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAE9D,OAAO,EAAE,gBAAgB,EAAE,KAAK,iBAAiB,EAAE,KAAK,oBAAoB,EAAE,MAAM,UAAU,CAAA;AAE9F,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAA;AACrC,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAA;AAE5C,YAAY,EACV,WAAW,EACX,SAAS,EACT,YAAY,EACZ,QAAQ,EACR,UAAU,EACV,cAAc,EACd,UAAU,EACV,QAAQ,EACR,OAAO,EACP,KAAK,EACL,KAAK,EACL,eAAe,EACf,OAAO,EACP,aAAa,EACb,MAAM,EACN,WAAW,EACX,MAAM,EACN,WAAW,EACX,YAAY,GACb,MAAM,SAAS,CAAA;AAEhB,OAAO,EAAE,EAAE,EAAE,GAAG,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA"}
+{"version":3,"file":"cloudflare.d.ts","sourceRoot":"","sources":["../cloudflare.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAEtD,OAAO,EAAE,qBAAqB,EAAE,KAAK,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AACnF,OAAO,EAAE,yBAAyB,EAAE,KAAK,uBAAuB,EAAE,MAAM,sBAAsB,CAAA;AAE9F,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,YAAY,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAE9F,OAAO,EAAE,gBAAgB,EAAE,KAAK,iBAAiB,EAAE,KAAK,oBAAoB,EAAE,MAAM,UAAU,CAAA;AAE9F,YAAY,EACV,WAAW,EACX,SAAS,EACT,YAAY,EACZ,QAAQ,EACR,UAAU,EACV,cAAc,EACd,UAAU,EACV,QAAQ,EACR,OAAO,EACP,KAAK,EACL,KAAK,EACL,eAAe,EACf,OAAO,EACP,aAAa,EACb,MAAM,EACN,WAAW,EACX,MAAM,EACN,WAAW,EACX,YAAY,GACb,MAAM,SAAS,CAAA;AAEhB,OAAO,EAAE,EAAE,EAAE,GAAG,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA"}

package/dist/cloudflare.js

@@ -2,12 +2,9 @@
  * Cloudflare Workers compatible exports
  * This entry point excludes the file backend which uses Node.js APIs
  */
-export { create_corpus } from './corpus';
-export { create_store } from './store';
+export { create_corpus, create_store } from './corpus';
 export { create_memory_backend } from './backend/memory';
 export { create_cloudflare_backend } from './backend/cloudflare';
-export { json_codec, text_codec, binary_codec } from './codec';
+export { json_codec, text_codec, binary_codec, compute_hash, generate_version } from './utils';
 export { corpus_snapshots } from './schema';
-export { compute_hash } from './hash';
-export { generate_version } from './version';
 export { ok, err, define_store } from './types';

package/dist/codecs.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Codec implementations for serializing and deserializing data.
+ * @module Codecs
+ * @packageDocumentation
+ */
+export { json_codec, text_codec, binary_codec } from './utils';
+export type { Codec, ContentType } from './types';
+//# sourceMappingURL=codecs.d.ts.map

package/dist/codecs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codecs.d.ts","sourceRoot":"","sources":["../codecs.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAC9D,YAAY,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA"}

package/dist/codecs.js

@@ -0,0 +1,6 @@
+/**
+ * Codec implementations for serializing and deserializing data.
+ * @module Codecs
+ * @packageDocumentation
+ */
+export { json_codec, text_codec, binary_codec } from './utils';

package/dist/core.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Core corpus functionality for creating and managing versioned data stores.
+ * @module Core
+ * @packageDocumentation
+ */
+export { create_corpus, create_store } from './corpus';
+export { define_store, ok, err } from './types';
+export type { Corpus, CorpusBuilder, Store, StoreDefinition, Result, CorpusError, PutOpts, } from './types';
+//# sourceMappingURL=core.d.ts.map

package/dist/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../core.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AACtD,OAAO,EAAE,YAAY,EAAE,EAAE,EAAE,GAAG,EAAE,MAAM,SAAS,CAAA;AAC/C,YAAY,EACV,MAAM,EACN,aAAa,EACb,KAAK,EACL,eAAe,EACf,MAAM,EACN,WAAW,EACX,OAAO,GACR,MAAM,SAAS,CAAA"}

package/dist/core.js

@@ -0,0 +1,7 @@
+/**
+ * Core corpus functionality for creating and managing versioned data stores.
+ * @module Core
+ * @packageDocumentation
+ */
+export { create_corpus, create_store } from './corpus';
+export { define_store, ok, err } from './types';

package/dist/corpus.d.ts

@@ -1,3 +1,70 @@
-import type { CorpusBuilder } from './types';
+/**
+ * @module Core
+ * @description Core corpus and store creation functions.
+ */
+import type { Backend, CorpusBuilder, StoreDefinition, Store } from './types';
+/**
+ * Creates a typed Store instance bound to a Backend.
+ * @category Core
+ * @group Builders
+ *
+ * Each store manages versioned snapshots of data with automatic deduplication:
+ * when the same content is stored twice, only one copy of the data is kept
+ * (identified by content hash), though separate metadata entries are created.
+ *
+ * Stores are typically created via `create_corpus().with_store()` rather than
+ * directly, which provides type-safe access through `corpus.stores.<id>`.
+ *
+ * @param backend - The storage backend for persistence
+ * @param definition - Store configuration including id and codec
+ * @returns A Store instance for the specified type
+ *
+ * @example
+ * ```ts
+ * const backend = create_memory_backend()
+ * const users = define_store('users', json_codec(UserSchema))
+ * const store = create_store(backend, users)
+ *
+ * // Store a snapshot
+ * const result = await store.put({ name: 'Alice', email: 'alice@example.com' })
+ * if (result.ok) {
+ *   console.log('Stored version:', result.value.version)
+ * }
+ *
+ * // Storing identical content reuses the same data_key (deduplication)
+ * const result2 = await store.put({ name: 'Alice', email: 'alice@example.com' })
+ * // result.value.data_key === result2.value.data_key (same content hash)
+ * ```
+ */
+export declare function create_store<T>(backend: Backend, definition: StoreDefinition<string, T>): Store<T>;
+/**
+ * Creates a new Corpus instance using the builder pattern.
+ *
+ * A Corpus is a collection of typed stores backed by a storage backend.
+ * Use the builder chain to configure: `with_backend()` → `with_store()` → `build()`.
+ *
+ * @category Core
+ * @group Builders
+ * @returns A CorpusBuilder to configure and build the Corpus
+ *
+ * @example
+ * ```ts
+ * import { z } from 'zod'
+ *
+ * const UserSchema = z.object({ name: z.string(), email: z.string() })
+ * const users = define_store('users', json_codec(UserSchema))
+ * const notes = define_store('notes', text_codec())
+ *
+ * const corpus = create_corpus()
+ *   .with_backend(create_memory_backend())
+ *   .with_store(users)
+ *   .with_store(notes)
+ *   .build()
+ *
+ * // Type-safe access to stores
+ * await corpus.stores.users.put({ name: 'Alice', email: 'alice@example.com' })
+ * await corpus.stores.notes.put('Hello, world!')
+ * ```
+ */
 export declare function create_corpus(): CorpusBuilder<{}>;
 //# sourceMappingURL=corpus.d.ts.map

package/dist/corpus.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"corpus.d.ts","sourceRoot":"","sources":["../corpus.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAmB,aAAa,EAA0B,MAAM,SAAS,CAAA;AAGrF,wBAAgB,aAAa,IAAI,aAAa,CAAC,EAAE,CAAC,CAoCjD"}
+{"version":3,"file":"corpus.d.ts","sourceRoot":"","sources":["../corpus.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAU,aAAa,EAAE,eAAe,EAAE,KAAK,EAAqD,MAAM,SAAS,CAAA;AAIxI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,eAAe,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAmJlG;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,aAAa,IAAI,aAAa,CAAC,EAAE,CAAC,CAoCjD"}