@f0rbit/corpus 0.1.4 → 0.1.6

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,EAAiE,YAAY,EAAE,MAAM,UAAU,CAAC;AAMrH,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;AA6IF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,uBAAuB,GAAG,OAAO,CAmOlF"}

package/dist/backend/cloudflare.js

@@ -2,10 +2,138 @@
  * @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, inArray } from "drizzle-orm";
+import { drizzle } from "drizzle-orm/d1";
+import { create_emitter, parse_snapshot_meta } from "../utils";
+import { ok, err } from "../types";
+import { corpus_snapshots } from "../schema";
+import { corpus_observations, create_observations_client } from "../observations";
+function create_cloudflare_storage(db) {
+    return {
+        async put_row(row) {
+            try {
+                await db.insert(corpus_observations).values(row);
+                return ok(row);
+            }
+            catch (cause) {
+                return err({
+                    kind: "storage_error",
+                    cause: cause,
+                    operation: "observations.put"
+                });
+            }
+        },
+        async get_row(id) {
+            try {
+                const rows = await db
+                    .select()
+                    .from(corpus_observations)
+                    .where(eq(corpus_observations.id, id))
+                    .limit(1);
+                return ok(rows[0] ?? null);
+            }
+            catch (cause) {
+                return err({
+                    kind: "storage_error",
+                    cause: cause,
+                    operation: "observations.get"
+                });
+            }
+        },
+        async *query_rows(opts = {}) {
+            const conditions = [];
+            if (opts.type) {
+                if (Array.isArray(opts.type)) {
+                    conditions.push(inArray(corpus_observations.type, opts.type));
+                }
+                else {
+                    conditions.push(eq(corpus_observations.type, opts.type));
+                }
+            }
+            if (opts.source_store_id) {
+                conditions.push(eq(corpus_observations.source_store_id, opts.source_store_id));
+            }
+            if (opts.source_version) {
+                conditions.push(eq(corpus_observations.source_version, opts.source_version));
+            }
+            if (opts.source_prefix) {
+                conditions.push(like(corpus_observations.source_version, `${opts.source_prefix}%`));
+            }
+            if (opts.created_after) {
+                conditions.push(gt(corpus_observations.created_at, opts.created_after));
+            }
+            if (opts.created_before) {
+                conditions.push(lt(corpus_observations.created_at, opts.created_before));
+            }
+            if (opts.observed_after) {
+                conditions.push(gt(corpus_observations.observed_at, opts.observed_after));
+            }
+            if (opts.observed_before) {
+                conditions.push(lt(corpus_observations.observed_at, opts.observed_before));
+            }
+            let query = db
+                .select()
+                .from(corpus_observations)
+                .where(conditions.length > 0 ? and(...conditions) : undefined)
+                .orderBy(desc(corpus_observations.created_at));
+            if (opts.limit) {
+                query = query.limit(opts.limit);
+            }
+            const rows = await query;
+            for (const row of rows) {
+                yield row;
+            }
+        },
+        async delete_row(id) {
+            try {
+                const existing = await db
+                    .select()
+                    .from(corpus_observations)
+                    .where(eq(corpus_observations.id, id))
+                    .limit(1);
+                if (existing.length === 0) {
+                    return ok(false);
+                }
+                await db.delete(corpus_observations).where(eq(corpus_observations.id, id));
+                return ok(true);
+            }
+            catch (cause) {
+                return err({
+                    kind: "storage_error",
+                    cause: cause,
+                    operation: "observations.delete"
+                });
+            }
+        },
+        async delete_by_source(store_id, version, path) {
+            try {
+                const conditions = [
+                    eq(corpus_observations.source_store_id, store_id),
+                    eq(corpus_observations.source_version, version)
+                ];
+                if (path !== undefined) {
+                    conditions.push(eq(corpus_observations.source_path, path));
+                }
+                const toDelete = await db
+                    .select()
+                    .from(corpus_observations)
+                    .where(and(...conditions));
+                const count = toDelete.length;
+                if (count > 0) {
+                    await db.delete(corpus_observations).where(and(...conditions));
+                }
+                return ok(count);
+            }
+            catch (cause) {
+                return err({
+                    kind: "storage_error",
+                    cause: cause,
+                    operation: "observations.delete_by_source"
+                });
+            }
+        }
+    };
+}
 /**
  * Creates a Cloudflare Workers storage backend using D1 and R2.
  * @category Backends
@@ -45,22 +173,9 @@ 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 emit = create_emitter(on_event);
+    function snapshot_row_to_meta(row) {
+        return parse_snapshot_meta(row);
     }
     const metadata = {
         async get(store_id, version) {
@@ -71,15 +186,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));
+                return ok(snapshot_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 +227,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);
             }
         },
@@ -154,32 +267,27 @@ export function create_cloudflare_backend(config) {
             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))) {
+                const meta = snapshot_row_to_meta(row);
+                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));
+                return ok(snapshot_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);
             }
         },
@@ -193,7 +301,7 @@ export function create_cloudflare_backend(config) {
               AND json_extract(value, '$.version') = ${parent_version}
           )`);
             for (const row of rows) {
-                yield row_to_meta(row);
+                yield snapshot_row_to_meta(row);
             }
         },
         async find_by_hash(store_id, content_hash) {
@@ -204,7 +312,7 @@ export function create_cloudflare_backend(config) {
                     .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;
+                return row ? snapshot_row_to_meta(row) : null;
             }
             catch {
                 return null;
@@ -215,9 +323,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 +333,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 +344,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 +355,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);
             }
         },
@@ -262,5 +370,7 @@ export function create_cloudflare_backend(config) {
             }
         },
     };
-    return { metadata, data, on_event };
+    const storage = create_cloudflare_storage(db);
+    const observations = create_observations_client(storage, metadata);
+    return { metadata, data, observations, on_event };
 }

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,EAAiE,YAAY,EAAE,MAAM,UAAU,CAAC;AAQrH,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,CA6MtE"}

package/dist/backend/file.js

@@ -2,9 +2,11 @@
  * @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 { create_observations_client, create_observations_storage } from "../observations";
+import { ok, err } from "../types";
+import { to_bytes, create_emitter, filter_snapshots, parse_snapshot_meta } from "../utils";
+import { mkdir, readdir } from "node:fs/promises";
+import { join, dirname } from "node:path";
 /**
  * Creates a file-system storage backend for local persistence.
  * @category Backends
@@ -38,29 +40,22 @@ import { join, dirname } from 'node:path';
  */
 export function create_file_backend(config) {
     const { base_path, on_event } = config;
-    function emit(event) {
-        on_event?.(event);
-    }
+    const emit = create_emitter(on_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') {
-                    return value ? new Date(value) : value;
-                }
-                return value;
-            });
-            return new Map(entries);
+            const entries = JSON.parse(content);
+            return new Map(entries.map(([key, raw]) => [key, parse_snapshot_meta(raw)]));
         }
         catch {
             return new Map();
@@ -76,9 +71,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,36 +81,25 @@ 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) {
             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;
+            const filtered = filter_snapshots(Array.from(store_meta.values()), opts);
             let count = 0;
-            for (const meta of matches.slice(0, limit)) {
+            for (const meta of filtered) {
                 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 +110,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 +118,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 +128,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 +145,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(),
@@ -175,25 +158,12 @@ export function create_file_backend(config) {
             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);
-                }
+                const bytes = await to_bytes(input);
+                await Bun.write(path, bytes);
                 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 +176,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) {
@@ -215,15 +185,43 @@ export function create_file_backend(config) {
             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;
+    const file_path = join(base_path, "_observations.json");
+    async function read_observations() {
+        const file = Bun.file(file_path);
+        if (!(await file.exists()))
+            return [];
+        try {
+            return await file.json();
+        }
+        catch {
+            return [];
+        }
     }
-    return result;
+    async function write_observations(rows) {
+        await Bun.write(file_path, JSON.stringify(rows, null, 2));
+    }
+    const storage = create_observations_storage({
+        get_all: read_observations,
+        set_all: write_observations,
+        get_one: async (id) => {
+            const rows = await read_observations();
+            return rows.find(r => r.id === id) ?? null;
+        },
+        add_one: async (row) => {
+            const rows = await read_observations();
+            rows.push(row);
+            await write_observations(rows);
+        },
+        remove_one: async (id) => {
+            const rows = await read_observations();
+            const idx = rows.findIndex(r => r.id === id);
+            if (idx === -1)
+                return false;
+            rows.splice(idx, 1);
+            await write_observations(rows);
+            return true;
+        }
+    });
+    const observations = create_observations_client(storage, metadata);
+    return { metadata, data, observations, on_event };
 }

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"layered.d.ts","sourceRoot":"","sources":["../../backend/layered.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAiG,MAAM,UAAU,CAAA;AAItI,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,CAkJ9E"}