@f0rbit/corpus 0.1.9 → 0.2.0

package/dist/backend/base.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @module Backend Base
+ * @description Base abstraction layer for backend implementations.
+ */
+import type { MetadataClient, DataClient, SnapshotMeta, CorpusEvent } from "../types";
+export type MetadataStorage = {
+    get: (store_id: string, version: string) => Promise<SnapshotMeta | null>;
+    put: (meta: SnapshotMeta) => Promise<void>;
+    delete: (store_id: string, version: string) => Promise<void>;
+    list: (store_id: string) => AsyncIterable<SnapshotMeta>;
+    find_by_hash: (store_id: string, hash: string) => Promise<SnapshotMeta | null>;
+};
+export type DataStorage = {
+    get: (data_key: string) => Promise<Uint8Array | null>;
+    put: (data_key: string, data: Uint8Array) => Promise<void>;
+    delete: (data_key: string) => Promise<void>;
+    exists: (data_key: string) => Promise<boolean>;
+};
+type Emit = (event: CorpusEvent) => void;
+export declare function create_metadata_client(storage: MetadataStorage, emit: Emit): MetadataClient;
+export declare function create_data_client(storage: DataStorage, emit: Emit): DataClient;
+export {};
+//# sourceMappingURL=base.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../backend/base.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,cAAc,EACd,UAAU,EACV,YAAY,EAGZ,WAAW,EAGZ,MAAM,UAAU,CAAC;AAIlB,MAAM,MAAM,eAAe,GAAG;IAC5B,GAAG,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAAC;IACzE,GAAG,EAAE,CAAC,IAAI,EAAE,YAAY,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3C,MAAM,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7D,IAAI,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,aAAa,CAAC,YAAY,CAAC,CAAC;IACxD,YAAY,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAAC;CAChF,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,GAAG,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC;IACtD,GAAG,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3D,MAAM,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5C,MAAM,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CAChD,CAAC;AAEF,KAAK,IAAI,GAAG,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;AAEzC,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,eAAe,EACxB,IAAI,EAAE,IAAI,GACT,cAAc,CAoEhB;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,IAAI,GAAG,UAAU,CA0C/E"}

package/dist/backend/base.js

@@ -0,0 +1,100 @@
+/**
+ * @module Backend Base
+ * @description Base abstraction layer for backend implementations.
+ */
+import { ok, err } from "../types";
+import { to_bytes, filter_snapshots } from "../utils";
+export function create_metadata_client(storage, emit) {
+    return {
+        async get(store_id, version) {
+            const meta = await storage.get(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) {
+            await storage.put(meta);
+            emit({ type: "meta_put", store_id: meta.store_id, version: meta.version });
+            return ok(undefined);
+        },
+        async delete(store_id, version) {
+            await storage.delete(store_id, version);
+            emit({ type: "meta_delete", store_id, version });
+            return ok(undefined);
+        },
+        async *list(store_id, opts) {
+            const all = [];
+            for await (const meta of storage.list(store_id)) {
+                all.push(meta);
+            }
+            const filtered = filter_snapshots(all, opts);
+            let count = 0;
+            for (const meta of filtered) {
+                yield meta;
+                count++;
+            }
+            emit({ type: "meta_list", store_id, count });
+        },
+        async get_latest(store_id) {
+            let latest = null;
+            for await (const meta of storage.list(store_id)) {
+                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 await (const meta of storage.list("")) {
+                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) {
+            return storage.find_by_hash(store_id, content_hash);
+        },
+    };
+}
+export function create_data_client(storage, emit) {
+    return {
+        async get(data_key) {
+            const bytes = await storage.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) {
+            const bytes = await to_bytes(input);
+            await storage.put(data_key, bytes);
+            return ok(undefined);
+        },
+        async delete(data_key) {
+            await storage.delete(data_key);
+            return ok(undefined);
+        },
+        async exists(data_key) {
+            return storage.exists(data_key);
+        },
+    };
+}

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,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"}
+{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../backend/file.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAgB,YAAY,EAAE,MAAM,UAAU,CAAC;AASpE,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,CAiKtE"}

package/dist/backend/file.js

@@ -3,10 +3,10 @@
  * @description File-system storage backend for local persistence.
  */
 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 { create_emitter, parse_snapshot_meta } from "../utils";
 import { mkdir, readdir } from "node:fs/promises";
 import { join, dirname } from "node:path";
+import { create_metadata_client, create_data_client } from "./base";
 /**
  * Creates a file-system storage backend for local persistence.
  * @category Backends
@@ -67,68 +67,47 @@ export function create_file_backend(config) {
         const entries = Array.from(meta_map.entries());
         await Bun.write(path, JSON.stringify(entries));
     }
-    const metadata = {
+    async function* list_all_stores() {
+        try {
+            const entries = await readdir(base_path, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory() && !entry.name.startsWith("_")) {
+                    yield entry.name;
+                }
+            }
+        }
+        catch { }
+    }
+    const metadata_storage = {
         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);
+            return store_meta.get(version) ?? null;
         },
         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 filtered = filter_snapshots(Array.from(store_meta.values()), opts);
-            let count = 0;
-            for (const meta of filtered) {
-                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;
+        async *list(store_id) {
+            if (store_id) {
+                const store_meta = await read_store_meta(store_id);
+                for (const meta of store_meta.values()) {
+                    yield 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);
+            else {
+                for await (const sid of list_all_stores()) {
+                    const store_meta = await read_store_meta(sid);
                     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;
+                        yield meta;
                     }
                 }
             }
-            catch { }
         },
         async find_by_hash(store_id, content_hash) {
             const store_meta = await read_store_meta(store_id);
@@ -140,43 +119,24 @@ export function create_file_backend(config) {
             return null;
         },
     };
-    const data = {
+    const data_storage = {
         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()),
-            });
+            if (!(await file.exists()))
+                return null;
+            return new Uint8Array(await file.arrayBuffer());
         },
-        async put(data_key, input) {
+        async put(data_key, data) {
             const path = data_path(data_key);
             await mkdir(dirname(path), { recursive: true });
-            try {
-                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" });
-            }
+            await Bun.write(path, data);
         },
         async delete(data_key) {
             const path = data_path(data_key);
-            try {
-                const file = Bun.file(path);
-                if (await file.exists()) {
-                    await file.delete();
-                }
-                return ok(undefined);
-            }
-            catch (cause) {
-                return err({ kind: "storage_error", cause: cause, operation: "delete" });
+            const file = Bun.file(path);
+            if (await file.exists()) {
+                await file.delete();
             }
         },
         async exists(data_key) {
@@ -185,6 +145,8 @@ export function create_file_backend(config) {
             return file.exists();
         },
     };
+    const metadata = create_metadata_client(metadata_storage, emit);
+    const data = create_data_client(data_storage, emit);
     const file_path = join(base_path, "_observations.json");
     async function read_observations() {
         const file = Bun.file(file_path);
@@ -205,7 +167,7 @@ export function create_file_backend(config) {
         set_all: write_observations,
         get_one: async (id) => {
             const rows = await read_observations();
-            return rows.find(r => r.id === id) ?? null;
+            return rows.find((r) => r.id === id) ?? null;
         },
         add_one: async (row) => {
             const rows = await read_observations();
@@ -214,13 +176,13 @@ export function create_file_backend(config) {
         },
         remove_one: async (id) => {
             const rows = await read_observations();
-            const idx = rows.findIndex(r => r.id === id);
+            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/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,EAAiE,MAAM,UAAU,CAAC;AAKvG,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7C,MAAM,MAAM,oBAAoB,GAAG;IAClC,QAAQ,CAAC,EAAE,YAAY,CAAC;CACxB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,CAAC,EAAE,oBAAoB,GAAG,OAAO,CA4I7E"}
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../backend/memory.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAgB,MAAM,UAAU,CAAC;AAItD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAI7C,MAAM,MAAM,oBAAoB,GAAG;IAClC,QAAQ,CAAC,EAAE,YAAY,CAAC;CACxB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAoF7E"}

package/dist/backend/memory.js

@@ -3,8 +3,8 @@
  * @description In-memory storage backend for testing and development.
  */
 import { create_observations_client, create_observations_storage } from "../observations";
-import { ok, err } from "../types";
-import { to_bytes, create_emitter, filter_snapshots } from "../utils";
+import { create_emitter } from "../utils";
+import { create_metadata_client, create_data_client } from "./base";
 /**
  * Creates an in-memory storage backend.
  * @category Backends
@@ -40,61 +40,22 @@ export function create_memory_backend(options) {
     function make_meta_key(store_id, version) {
         return `${store_id}:${version}`;
     }
-    const metadata = {
+    const metadata_storage = {
         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);
+            return meta_store.get(make_meta_key(store_id, version)) ?? null;
         },
         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 store_metas = [];
-            for (const [key, meta] of meta_store) {
-                if (key.startsWith(prefix)) {
-                    store_metas.push(meta);
-                }
-            }
-            const filtered = filter_snapshots(store_metas, opts);
-            let count = 0;
-            for (const meta of filtered) {
-                yield meta;
-                count++;
-            }
-            emit({ type: "meta_list", store_id, count });
         },
-        async get_latest(store_id) {
-            let latest = null;
-            const prefix = `${store_id}:`;
+        async *list(store_id) {
+            const prefix = store_id ? `${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)
+                if (!prefix || key.startsWith(prefix)) {
                     yield meta;
+                }
             }
         },
         async find_by_hash(store_id, content_hash) {
@@ -107,36 +68,22 @@ export function create_memory_backend(options) {
             return null;
         },
     };
-    const data = {
+    const data_storage = {
         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,
-            });
+            return data_store.get(data_key) ?? null;
         },
-        async put(data_key, input) {
-            const bytes = await to_bytes(input);
-            data_store.set(data_key, bytes);
-            return ok(undefined);
+        async put(data_key, data) {
+            data_store.set(data_key, data);
         },
         async delete(data_key) {
             data_store.delete(data_key);
-            return ok(undefined);
         },
         async exists(data_key) {
             return data_store.has(data_key);
         },
     };
+    const metadata = create_metadata_client(metadata_storage, emit);
+    const data = create_data_client(data_storage, emit);
     const storage = create_observations_storage({
         get_all: async () => Array.from(observation_store.values()),
         set_all: async (rows) => {
@@ -145,12 +92,14 @@ export function create_memory_backend(options) {
                 observation_store.set(row.id, row);
         },
         get_one: async (id) => observation_store.get(id) ?? null,
-        add_one: async (row) => { observation_store.set(row.id, row); },
+        add_one: async (row) => {
+            observation_store.set(row.id, row);
+        },
         remove_one: async (id) => {
             const had = observation_store.has(id);
             observation_store.delete(id);
             return had;
-        }
+        },
     });
     const observations = create_observations_client(storage, metadata);
     return { metadata, data, observations, on_event };

package/dist/backends.d.ts

@@ -7,5 +7,6 @@ export { create_memory_backend, type MemoryBackendOptions } from './backend/memo
 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 { create_metadata_client, create_data_client, type MetadataStorage, type DataStorage } from './backend/base';
 export type { Backend, MetadataClient, DataClient, DataHandle, EventHandler, CorpusEvent } from './types';
 //# sourceMappingURL=backends.d.ts.map

package/dist/backends.d.ts.map

@@ -1 +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"}
+{"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,OAAO,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,KAAK,eAAe,EAAE,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAA;AACnH,YAAY,EAAE,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,UAAU,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA"}

package/dist/backends.js

@@ -7,3 +7,4 @@ 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';
+export { create_metadata_client, create_data_client } from './backend/base';

package/dist/cloudflare.d.ts

@@ -9,4 +9,5 @@ export { json_codec, text_codec, binary_codec, compute_hash, generate_version }
 export { corpus_snapshots, type CorpusSnapshotRow, type CorpusSnapshotInsert } from './schema';
 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';
+export * from './observations';
 //# 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,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"}
+{"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;AAE/C,cAAc,gBAAgB,CAAA"}

package/dist/cloudflare.js

@@ -8,3 +8,4 @@ export { create_cloudflare_backend } from './backend/cloudflare';
 export { json_codec, text_codec, binary_codec, compute_hash, generate_version } from './utils';
 export { corpus_snapshots } from './schema';
 export { ok, err, define_store } from './types';
+export * from './observations';

package/dist/concurrency.d.ts

@@ -0,0 +1,78 @@
+/**
+ * @module Concurrency
+ * @description Utilities for controlling concurrent async operations.
+ */
+/**
+ * Semaphore for controlling concurrent operations.
+ *
+ * Limits the number of concurrent async operations by requiring
+ * callers to acquire a permit before proceeding. When all permits
+ * are taken, subsequent acquires wait until a permit is released.
+ *
+ * @example
+ * ```ts
+ * const semaphore = new Semaphore(3) // Allow 3 concurrent operations
+ *
+ * async function rateLimitedFetch(url: string) {
+ *   await semaphore.acquire()
+ *   try {
+ *     return await fetch(url)
+ *   } finally {
+ *     semaphore.release()
+ *   }
+ * }
+ *
+ * // Only 3 fetches will run concurrently
+ * await Promise.all(urls.map(rateLimitedFetch))
+ * ```
+ */
+export declare class Semaphore {
+    private permits;
+    private waiting;
+    constructor(permits: number);
+    /**
+     * Acquire a permit. Resolves immediately if available,
+     * otherwise waits until a permit is released.
+     */
+    acquire(): Promise<void>;
+    /**
+     * Release a permit, allowing the next waiting operation to proceed.
+     */
+    release(): void;
+}
+/**
+ * Map over array with controlled concurrency.
+ *
+ * Unlike Promise.all which starts all operations at once, this limits
+ * concurrent operations. Results are returned in the same order as inputs.
+ *
+ * @param items - Array of items to process
+ * @param mapper - Async function to apply to each item
+ * @param concurrency - Maximum number of concurrent operations
+ * @returns Array of results in the same order as inputs
+ *
+ * @example
+ * ```ts
+ * // Process 100 items, but only 5 at a time
+ * const results = await parallel_map(
+ *   urls,
+ *   async (url, index) => {
+ *     console.log(`Fetching ${index + 1}/${urls.length}`)
+ *     return fetch(url).then(r => r.json())
+ *   },
+ *   5
+ * )
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Use with AI APIs that have rate limits
+ * const summaries = await parallel_map(
+ *   documents,
+ *   doc => summarize(doc),
+ *   3 // Only 3 concurrent API calls
+ * )
+ * ```
+ */
+export declare const parallel_map: <T, R>(items: T[], mapper: (item: T, index: number) => Promise<R>, concurrency: number) => Promise<R[]>;
+//# sourceMappingURL=concurrency.d.ts.map

package/dist/concurrency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"concurrency.d.ts","sourceRoot":"","sources":["../concurrency.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,SAAS;IACrB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,OAAO,CAAyB;gBAE5B,OAAO,EAAE,MAAM;IAI3B;;;OAGG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAU9B;;OAEG;IACH,OAAO,IAAI,IAAI;CAQf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,eAAO,MAAM,YAAY,GAAU,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,EAAE,aAAa,MAAM,KAAG,OAAO,CAAC,CAAC,EAAE,CAgBrI,CAAC"}