@f0rbit/corpus 0.1.4 → 0.1.5

package/dist/backend/cloudflare.d.ts

@@ -2,7 +2,7 @@
  * @module Backends
  * @description Cloudflare Workers storage backend using D1 and R2.
  */
-import type { Backend, EventHandler } from '../types';
+import type { Backend, EventHandler } from "../types";
 type D1Database = {
     prepare: (sql: string) => unknown;
 };

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

@@ -1 +1 @@
-{"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"}
+{"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,CAAC;AAI5I,KAAK,UAAU,GAAG;IAAE,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAA;CAAE,CAAC;AACxD,KAAK,QAAQ,GAAG;IACf,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,CAAC;IACpH,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,CAAC,UAAU,CAAC,GAAG,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACnF,MAAM,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACvC,IAAI,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC,CAAC;CACvD,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACrC,EAAE,EAAE,UAAU,CAAC;IACf,EAAE,EAAE,QAAQ,CAAC;IACb,QAAQ,CAAC,EAAE,YAAY,CAAC;CACxB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,uBAAuB,GAAG,OAAO,CA8OlF"}

package/dist/backend/cloudflare.js

@@ -2,10 +2,10 @@
  * @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';
+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
@@ -71,15 +71,15 @@ export function create_cloudflare_backend(config) {
                     .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 });
+                emit({ type: "meta_get", store_id, version, found: !!row });
                 if (!row) {
-                    return err({ kind: 'not_found', store_id, version });
+                    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 });
+                const error = { kind: "storage_error", cause: cause, operation: "metadata.get" };
+                emit({ type: "error", error });
                 return err(error);
             }
         },
@@ -112,26 +112,24 @@ export function create_cloudflare_backend(config) {
                         tags: meta.tags ? JSON.stringify(meta.tags) : null,
                     },
                 });
-                emit({ type: 'meta_put', store_id: meta.store_id, version: meta.version });
+                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 });
+                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 });
+                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 });
+                const error = { kind: "storage_error", cause: cause, operation: "metadata.delete" };
+                emit({ type: "error", error });
                 return err(error);
             }
         },
@@ -155,31 +153,26 @@ export function create_cloudflare_backend(config) {
             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))) {
+                if (opts?.tags?.length && !opts.tags.every(t => meta.tags?.includes(t))) {
                     continue;
                 }
                 yield meta;
                 count++;
             }
-            emit({ type: 'meta_list', store_id, 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 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 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 });
+                const error = { kind: "storage_error", cause: cause, operation: "metadata.get_latest" };
+                emit({ type: "error", error });
                 return err(error);
             }
         },
@@ -215,9 +208,9 @@ export function create_cloudflare_backend(config) {
         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 });
+                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 err({ kind: "not_found", store_id: data_key, version: "" });
                 }
                 return ok({
                     stream: () => object.body,
@@ -225,8 +218,8 @@ export function create_cloudflare_backend(config) {
                 });
             }
             catch (cause) {
-                const error = { kind: 'storage_error', cause: cause, operation: 'data.get' };
-                emit({ type: 'error', error });
+                const error = { kind: "storage_error", cause: cause, operation: "data.get" };
+                emit({ type: "error", error });
                 return err(error);
             }
         },
@@ -236,8 +229,8 @@ export function create_cloudflare_backend(config) {
                 return ok(undefined);
             }
             catch (cause) {
-                const error = { kind: 'storage_error', cause: cause, operation: 'data.put' };
-                emit({ type: 'error', error });
+                const error = { kind: "storage_error", cause: cause, operation: "data.put" };
+                emit({ type: "error", error });
                 return err(error);
             }
         },
@@ -247,8 +240,8 @@ export function create_cloudflare_backend(config) {
                 return ok(undefined);
             }
             catch (cause) {
-                const error = { kind: 'storage_error', cause: cause, operation: 'data.delete' };
-                emit({ type: 'error', error });
+                const error = { kind: "storage_error", cause: cause, operation: "data.delete" };
+                emit({ type: "error", error });
                 return err(error);
             }
         },

package/dist/backend/file.d.ts

@@ -2,7 +2,7 @@
  * @module Backends
  * @description File-system storage backend for local persistence.
  */
-import type { Backend, EventHandler } from '../types';
+import type { Backend, EventHandler } from "../types";
 export type FileBackendConfig = {
     base_path: string;
     on_event?: EventHandler;

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

@@ -1 +1 @@
-{"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"}
+{"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,CAAC;AAK5I,MAAM,MAAM,iBAAiB,GAAG;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,YAAY,CAAC;CACxB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAkMtE"}

package/dist/backend/file.js

@@ -2,9 +2,9 @@
  * @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';
+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
@@ -42,20 +42,20 @@ export function create_file_backend(config) {
         on_event?.(event);
     }
     function meta_path(store_id) {
-        return join(base_path, store_id, '_meta.json');
+        return join(base_path, store_id, "_meta.json");
     }
     function data_path(data_key) {
-        return join(base_path, '_data', `${data_key.replace(/\//g, '_')}.bin`);
+        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())
+        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') {
+                if (key === "created_at" || key === "invoked_at") {
                     return value ? new Date(value) : value;
                 }
                 return value;
@@ -76,9 +76,9 @@ export function create_file_backend(config) {
         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 });
+            emit({ type: "meta_get", store_id, version, found: !!meta });
             if (!meta) {
-                return err({ kind: 'not_found', store_id, version });
+                return err({ kind: "not_found", store_id, version });
             }
             return ok(meta);
         },
@@ -86,14 +86,14 @@ export function create_file_backend(config) {
             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 });
+            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 });
+            emit({ type: "meta_delete", store_id, version });
             return ok(undefined);
         },
         async *list(store_id, opts) {
@@ -104,7 +104,7 @@ export function create_file_backend(config) {
                     return false;
                 if (opts?.after && meta.created_at <= opts.after)
                     return false;
-                if (opts?.tags?.length && !opts.tags.some(t => meta.tags?.includes(t)))
+                if (opts?.tags?.length && !opts.tags.every(t => meta.tags?.includes(t)))
                     return false;
                 return true;
             })
@@ -115,7 +115,7 @@ export function create_file_backend(config) {
                 yield meta;
                 count++;
             }
-            emit({ type: 'meta_list', store_id, count });
+            emit({ type: "meta_list", store_id, count });
         },
         async get_latest(store_id) {
             const store_meta = await read_store_meta(store_id);
@@ -126,7 +126,7 @@ export function create_file_backend(config) {
                 }
             }
             if (!latest) {
-                return err({ kind: 'not_found', store_id, version: 'latest' });
+                return err({ kind: "not_found", store_id, version: "latest" });
             }
             return ok(latest);
         },
@@ -134,7 +134,7 @@ export function create_file_backend(config) {
             try {
                 const entries = await readdir(base_path, { withFileTypes: true });
                 for (const entry of entries) {
-                    if (!entry.isDirectory() || entry.name.startsWith('_'))
+                    if (!entry.isDirectory() || entry.name.startsWith("_"))
                         continue;
                     const store_meta = await read_store_meta(entry.name);
                     for (const meta of store_meta.values()) {
@@ -144,8 +144,7 @@ export function create_file_backend(config) {
                     }
                 }
             }
-            catch {
-            }
+            catch { }
         },
         async find_by_hash(store_id, content_hash) {
             const store_meta = await read_store_meta(store_id);
@@ -162,9 +161,9 @@ export function create_file_backend(config) {
             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 });
+            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 err({ kind: "not_found", store_id: data_key, version: "" });
             }
             return ok({
                 stream: () => file.stream(),
@@ -193,7 +192,7 @@ export function create_file_backend(config) {
                 return ok(undefined);
             }
             catch (cause) {
-                return err({ kind: 'storage_error', cause: cause, operation: 'put' });
+                return err({ kind: "storage_error", cause: cause, operation: "put" });
             }
         },
         async delete(data_key) {
@@ -206,7 +205,7 @@ export function create_file_backend(config) {
                 return ok(undefined);
             }
             catch (cause) {
-                return err({ kind: 'storage_error', cause: cause, operation: 'delete' });
+                return err({ kind: "storage_error", cause: cause, operation: "delete" });
             }
         },
         async exists(data_key) {

package/dist/backend/memory.d.ts

@@ -2,7 +2,7 @@
  * @module Backends
  * @description In-memory storage backend for testing and development.
  */
-import type { Backend, EventHandler } from '../types';
+import type { Backend, EventHandler } from "../types";
 export type MemoryBackendOptions = {
     on_event?: EventHandler;
 };

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

@@ -1 +1 @@
-{"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"}
+{"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,CAAC;AAG5I,MAAM,MAAM,oBAAoB,GAAG;IAClC,QAAQ,CAAC,EAAE,YAAY,CAAC;CACxB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAgJ7E"}

package/dist/backend/memory.js

@@ -2,7 +2,7 @@
  * @module Backends
  * @description In-memory storage backend for testing and development.
  */
-import { ok, err } from '../types';
+import { ok, err } from "../types";
 /**
  * Creates an in-memory storage backend.
  * @category Backends
@@ -42,20 +42,20 @@ export function create_memory_backend(options) {
     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 });
+            emit({ type: "meta_get", store_id, version, found: !!meta });
             if (!meta) {
-                return err({ kind: 'not_found', store_id, version });
+                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 });
+            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 });
+            emit({ type: "meta_delete", store_id, version });
             return ok(undefined);
         },
         async *list(store_id, opts) {
@@ -68,7 +68,7 @@ export function create_memory_backend(options) {
                     continue;
                 if (opts?.after && meta.created_at <= opts.after)
                     continue;
-                if (opts?.tags?.length && !opts.tags.some(t => meta.tags?.includes(t)))
+                if (opts?.tags?.length && !opts.tags.every(t => meta.tags?.includes(t)))
                     continue;
                 matches.push(meta);
             }
@@ -79,7 +79,7 @@ export function create_memory_backend(options) {
                 yield match;
                 count++;
             }
-            emit({ type: 'meta_list', store_id, count });
+            emit({ type: "meta_list", store_id, count });
         },
         async get_latest(store_id) {
             let latest = null;
@@ -92,7 +92,7 @@ export function create_memory_backend(options) {
                 }
             }
             if (!latest) {
-                return err({ kind: 'not_found', store_id, version: 'latest' });
+                return err({ kind: "not_found", store_id, version: "latest" });
             }
             return ok(latest);
         },
@@ -116,16 +116,16 @@ export function create_memory_backend(options) {
     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 });
+            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 err({ kind: "not_found", store_id: data_key, version: "" });
             }
             return ok({
                 stream: () => new ReadableStream({
                     start(controller) {
                         controller.enqueue(bytes);
                         controller.close();
-                    }
+                    },
                 }),
                 bytes: async () => bytes,
             });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@f0rbit/corpus",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "A functional snapshotting library for TypeScript with versioned data storage, lineage tracking, and multiple backend support",
   "module": "dist/index.js",
   "main": "dist/index.js",

package/dist/codec.d.ts

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

package/dist/codec.d.ts.map

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

package/dist/codec.js

@@ -1,21 +0,0 @@
-export function json_codec(schema) {
-    return {
-        content_type: "application/json",
-        encode: (value) => new TextEncoder().encode(JSON.stringify(value)),
-        decode: (bytes) => schema.parse(JSON.parse(new TextDecoder().decode(bytes))),
-    };
-}
-export function text_codec() {
-    return {
-        content_type: "text/plain",
-        encode: (value) => new TextEncoder().encode(value),
-        decode: (bytes) => new TextDecoder().decode(bytes),
-    };
-}
-export function binary_codec() {
-    return {
-        content_type: "application/octet-stream",
-        encode: (value) => value,
-        decode: (bytes) => bytes,
-    };
-}

package/dist/hash.d.ts

@@ -1,2 +0,0 @@
-export declare function compute_hash(data: Uint8Array): Promise<string>;
-//# sourceMappingURL=hash.d.ts.map

package/dist/hash.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../hash.ts"],"names":[],"mappings":"AAAA,wBAAsB,YAAY,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAIpE"}

package/dist/hash.js

@@ -1,5 +0,0 @@
-export async function compute_hash(data) {
-    const hash_buffer = await crypto.subtle.digest('SHA-256', data);
-    const hash_array = new Uint8Array(hash_buffer);
-    return Array.from(hash_array).map(b => b.toString(16).padStart(2, '0')).join('');
-}

package/dist/store.d.ts

@@ -1,3 +0,0 @@
-import type { Backend, Store, StoreDefinition } from './types';
-export declare function create_store<T>(backend: Backend, definition: StoreDefinition<string, T>): Store<T>;
-//# sourceMappingURL=store.d.ts.map

package/dist/store.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,eAAe,EAA8C,MAAM,SAAS,CAAA;AAK1G,wBAAgB,YAAY,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,eAAe,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CA+IlG"}

package/dist/store.js

@@ -1,125 +0,0 @@
-import { ok, err } from './types';
-import { compute_hash } from './hash';
-import { generate_version } from './version';
-export function create_store(backend, definition) {
-    const { id, codec } = definition;
-    function emit(event) {
-        backend.on_event?.(event);
-    }
-    function make_data_key(store_id, content_hash) {
-        return `${store_id}/${content_hash}`;
-    }
-    return {
-        id,
-        codec,
-        async put(data, opts) {
-            const version = generate_version();
-            let bytes;
-            try {
-                bytes = codec.encode(data);
-            }
-            catch (cause) {
-                const error = { kind: 'encode_error', cause: cause };
-                emit({ type: 'error', error });
-                return err(error);
-            }
-            const content_hash = await compute_hash(bytes);
-            // deduplication: reuse existing data_key if content already exists
-            const existing = await backend.metadata.find_by_hash(id, content_hash);
-            const deduplicated = existing !== null;
-            const data_key = deduplicated ? existing.data_key : make_data_key(id, content_hash);
-            if (!deduplicated) {
-                const data_result = await backend.data.put(data_key, bytes);
-                if (!data_result.ok) {
-                    emit({ type: 'error', error: data_result.error });
-                    return data_result;
-                }
-            }
-            emit({ type: 'data_put', store_id: id, version, size_bytes: bytes.length, deduplicated });
-            const meta = {
-                store_id: id,
-                version,
-                parents: opts?.parents ?? [],
-                created_at: new Date(),
-                invoked_at: opts?.invoked_at,
-                content_hash,
-                content_type: codec.content_type,
-                size_bytes: bytes.length,
-                data_key,
-                tags: opts?.tags,
-            };
-            const meta_result = await backend.metadata.put(meta);
-            if (!meta_result.ok) {
-                emit({ type: 'error', error: meta_result.error });
-                return meta_result;
-            }
-            emit({ type: 'snapshot_put', store_id: id, version, content_hash, deduplicated });
-            return ok(meta);
-        },
-        async get(version) {
-            const meta_result = await backend.metadata.get(id, version);
-            if (!meta_result.ok) {
-                emit({ type: 'snapshot_get', store_id: id, version, found: false });
-                return meta_result;
-            }
-            const meta = meta_result.value;
-            const data_result = await backend.data.get(meta.data_key);
-            if (!data_result.ok) {
-                emit({ type: 'error', error: data_result.error });
-                return data_result;
-            }
-            const bytes = await data_result.value.bytes();
-            let data;
-            try {
-                data = codec.decode(bytes);
-            }
-            catch (cause) {
-                const error = { kind: 'decode_error', cause: cause };
-                emit({ type: 'error', error });
-                return err(error);
-            }
-            emit({ type: 'snapshot_get', store_id: id, version, found: true });
-            return ok({ meta, data });
-        },
-        async get_latest() {
-            const meta_result = await backend.metadata.get_latest(id);
-            if (!meta_result.ok) {
-                return meta_result;
-            }
-            const meta = meta_result.value;
-            const data_result = await backend.data.get(meta.data_key);
-            if (!data_result.ok) {
-                return data_result;
-            }
-            const bytes = await data_result.value.bytes();
-            let data;
-            try {
-                data = codec.decode(bytes);
-            }
-            catch (cause) {
-                const error = { kind: 'decode_error', cause: cause };
-                emit({ type: 'error', error });
-                return err(error);
-            }
-            return ok({ meta, data });
-        },
-        async get_meta(version) {
-            return backend.metadata.get(id, version);
-        },
-        list(opts) {
-            return backend.metadata.list(id, opts);
-        },
-        async delete(version) {
-            const meta_result = await backend.metadata.get(id, version);
-            if (!meta_result.ok) {
-                return meta_result;
-            }
-            const delete_meta_result = await backend.metadata.delete(id, version);
-            if (!delete_meta_result.ok) {
-                return delete_meta_result;
-            }
-            emit({ type: 'meta_delete', store_id: id, version });
-            return ok(undefined);
-        },
-    };
-}

package/dist/version.d.ts

@@ -1,7 +0,0 @@
-/**
- * Generates a unique, sortable version string.
- * Format: base64url-encoded timestamp with optional sequence suffix for same-millisecond calls.
- * Versions sort lexicographically in chronological order.
- */
-export declare function generate_version(): string;
-//# sourceMappingURL=version.d.ts.map

package/dist/version.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../version.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,CA0BzC"}

package/dist/version.js

@@ -1,31 +0,0 @@
-let last_timestamp = 0;
-let sequence = 0;
-/**
- * Generates a unique, sortable version string.
- * Format: base64url-encoded timestamp with optional sequence suffix for same-millisecond calls.
- * Versions sort lexicographically in chronological order.
- */
-export function generate_version() {
-    const now = Date.now();
-    if (now === last_timestamp) {
-        sequence++;
-    }
-    else {
-        last_timestamp = now;
-        sequence = 0;
-    }
-    // base64url encode the timestamp (no padding, url-safe)
-    const timestamp_bytes = new Uint8Array(8);
-    const view = new DataView(timestamp_bytes.buffer);
-    view.setBigUint64(0, BigInt(now), false); // big-endian for lexicographic sorting
-    // trim leading zeros for compactness
-    let start = 0;
-    while (start < 7 && timestamp_bytes[start] === 0)
-        start++;
-    const trimmed = timestamp_bytes.slice(start);
-    const base64 = btoa(String.fromCharCode(...trimmed))
-        .replace(/\+/g, '-')
-        .replace(/\//g, '_')
-        .replace(/=/g, '');
-    return sequence > 0 ? `${base64}.${sequence}` : base64;
-}