@utilarium/overcontext 0.0.7 → 0.0.8-dev.20260226040805.d18adcf

package/dist/index.cjs

@@ -7,6 +7,8 @@ const fs = require('node:fs/promises');
 const node_fs = require('node:fs');
 const path = require('node:path');
 const yaml = require('js-yaml');
+const libFs = require('@fjell/lib-fs');
+const libGcs = require('@fjell/lib-gcs');
 
 function _interopNamespaceDefault(e) {
     const n = Object.create(null, { [Symbol.toStringTag]: { value: 'Module' } });
@@ -258,7 +260,7 @@ const yaml__namespace = /*#__PURE__*/_interopNamespaceDefault(yaml);
     }
 };
 
-function _define_property$1(obj, key, value) {
+function _define_property$5(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -273,25 +275,25 @@ function _define_property$1(obj, key, value) {
 }
 class StorageError extends Error {
     constructor(message, code, cause){
-        super(message), _define_property$1(this, "code", void 0), _define_property$1(this, "cause", void 0), this.code = code, this.cause = cause;
+        super(message), _define_property$5(this, "code", void 0), _define_property$5(this, "cause", void 0), this.code = code, this.cause = cause;
         this.name = 'StorageError';
     }
 }
 class EntityNotFoundError extends StorageError {
     constructor(entityType, entityId, namespace){
-        super(`Entity not found: ${entityType}/${entityId}${namespace ? ` in ${namespace}` : ''}`, 'ENTITY_NOT_FOUND'), _define_property$1(this, "entityType", void 0), _define_property$1(this, "entityId", void 0), _define_property$1(this, "namespace", void 0), this.entityType = entityType, this.entityId = entityId, this.namespace = namespace;
+        super(`Entity not found: ${entityType}/${entityId}${namespace ? ` in ${namespace}` : ''}`, 'ENTITY_NOT_FOUND'), _define_property$5(this, "entityType", void 0), _define_property$5(this, "entityId", void 0), _define_property$5(this, "namespace", void 0), this.entityType = entityType, this.entityId = entityId, this.namespace = namespace;
         this.name = 'EntityNotFoundError';
     }
 }
 class SchemaNotRegisteredError extends StorageError {
     constructor(entityType){
-        super(`Schema not registered for type: ${entityType}`, 'SCHEMA_NOT_REGISTERED'), _define_property$1(this, "entityType", void 0), this.entityType = entityType;
+        super(`Schema not registered for type: ${entityType}`, 'SCHEMA_NOT_REGISTERED'), _define_property$5(this, "entityType", void 0), this.entityType = entityType;
         this.name = 'SchemaNotRegisteredError';
     }
 }
 class ValidationError extends StorageError {
     constructor(message, validationErrors){
-        super(message, 'VALIDATION_ERROR'), _define_property$1(this, "validationErrors", void 0), this.validationErrors = validationErrors;
+        super(message, 'VALIDATION_ERROR'), _define_property$5(this, "validationErrors", void 0), this.validationErrors = validationErrors;
         this.name = 'ValidationError';
     }
 }
@@ -309,7 +311,7 @@ class ReadonlyStorageError extends StorageError {
 }
 class NamespaceNotFoundError extends StorageError {
     constructor(namespace){
-        super(`Namespace not found: ${namespace}`, 'NAMESPACE_NOT_FOUND'), _define_property$1(this, "namespace", void 0), this.namespace = namespace;
+        super(`Namespace not found: ${namespace}`, 'NAMESPACE_NOT_FOUND'), _define_property$5(this, "namespace", void 0), this.namespace = namespace;
         this.name = 'NamespaceNotFoundError';
     }
 }
@@ -329,7 +331,15 @@ class NamespaceNotFoundError extends StorageError {
         });
     };
     return {
-        ...provider,
+        get name () {
+            return provider.name;
+        },
+        get location () {
+            return provider.location;
+        },
+        get registry () {
+            return provider.registry;
+        },
         subscribe (handler) {
             handlers.add(handler);
             return ()=>handlers.delete(handler);
@@ -349,6 +359,24 @@ class NamespaceNotFoundError extends StorageError {
             handlers.clear(); // Clear all handlers to prevent memory leaks
             await provider.dispose();
         },
+        async isAvailable () {
+            return provider.isAvailable();
+        },
+        async get (type, id, namespace) {
+            return provider.get(type, id, namespace);
+        },
+        async getAll (type, namespace) {
+            return provider.getAll(type, namespace);
+        },
+        async find (filter) {
+            return provider.find(filter);
+        },
+        async exists (type, id, namespace) {
+            return provider.exists(type, id, namespace);
+        },
+        async count (filter) {
+            return provider.count(filter);
+        },
         async save (entity, namespace) {
             const existing = await provider.get(entity.type, entity.id, namespace);
             const saved = await provider.save(entity, namespace);
@@ -407,6 +435,15 @@ class NamespaceNotFoundError extends StorageError {
                 deletedCount: count
             });
             return count;
+        },
+        async listNamespaces () {
+            return provider.listNamespaces();
+        },
+        async namespaceExists (namespace) {
+            return provider.namespaceExists(namespace);
+        },
+        async listTypes (namespace) {
+            return provider.listTypes(namespace);
         }
     };
 };
@@ -1024,6 +1061,761 @@ const createMemoryProvider = (options)=>{
     };
 };
 
+function _define_property$4(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+/**
+ * StorageProvider backed by a FjellBackendAdapter.
+ * Delegates all persistence to the adapter and handles
+ * entity <-> raw record conversion at the boundary.
+ */ class FjellStorageProvider {
+    async initialize() {
+        return this.adapter.initialize();
+    }
+    async dispose() {
+        return this.adapter.dispose();
+    }
+    async isAvailable() {
+        return this.adapter.isAvailable();
+    }
+    async get(type, id, namespace) {
+        const raw = await this.adapter.get(type, id, namespace);
+        return raw ? this.toEntity(raw) : undefined;
+    }
+    async getAll(type, namespace) {
+        const raws = await this.adapter.getAll(type, namespace);
+        return raws.map((r)=>this.toEntity(r));
+    }
+    async find(filter) {
+        const types = this.resolveFilterTypes(filter);
+        const results = [];
+        for (const type of types){
+            const typeFilter = {
+                ...filter,
+                type
+            };
+            const raws = await this.adapter.find(type, typeFilter, filter.namespace);
+            results.push(...raws.map((r)=>this.toEntity(r)));
+        }
+        if (filter.limit && results.length > filter.limit) {
+            return results.slice(0, filter.limit);
+        }
+        return results;
+    }
+    async exists(type, id, namespace) {
+        return this.adapter.exists(type, id, namespace);
+    }
+    async count(filter) {
+        const types = this.resolveFilterTypes(filter);
+        let total = 0;
+        for (const type of types){
+            const typeFilter = {
+                ...filter,
+                type
+            };
+            total += await this.adapter.count(type, typeFilter, filter.namespace);
+        }
+        return total;
+    }
+    async save(entity, namespace) {
+        const raw = this.toRaw(entity);
+        const entityExists = await this.adapter.exists(entity.type, entity.id, namespace);
+        const result = entityExists ? await this.adapter.update(entity.type, entity.id, raw, namespace) : await this.adapter.create(entity.type, raw, namespace);
+        return this.toEntity(result);
+    }
+    async delete(type, id, namespace) {
+        return this.adapter.remove(type, id, namespace);
+    }
+    async saveBatch(entities, namespace) {
+        return Promise.all(entities.map((e)=>this.save(e, namespace)));
+    }
+    async deleteBatch(refs, namespace) {
+        let deleted = 0;
+        for (const ref of refs){
+            const removed = await this.adapter.remove(ref.type, ref.id, namespace);
+            if (removed) deleted++;
+        }
+        return deleted;
+    }
+    async listNamespaces() {
+        return this.adapter.listNamespaces();
+    }
+    async namespaceExists(namespace) {
+        return this.adapter.namespaceExists(namespace);
+    }
+    async listTypes(namespace) {
+        return this.adapter.listTypes(namespace);
+    }
+    toEntity(raw) {
+        const entity = {
+            ...raw
+        };
+        if (raw.createdAt && typeof raw.createdAt === 'string') {
+            entity.createdAt = new Date(raw.createdAt);
+        }
+        if (raw.updatedAt && typeof raw.updatedAt === 'string') {
+            entity.updatedAt = new Date(raw.updatedAt);
+        }
+        return entity;
+    }
+    toRaw(entity) {
+        const raw = {
+            ...entity
+        };
+        if (entity.createdAt) {
+            raw.createdAt = entity.createdAt.toISOString();
+        }
+        if (entity.updatedAt) {
+            raw.updatedAt = entity.updatedAt.toISOString();
+        }
+        return raw;
+    }
+    resolveFilterTypes(filter) {
+        if (filter.type) {
+            return Array.isArray(filter.type) ? filter.type : [
+                filter.type
+            ];
+        }
+        return this.registry.types();
+    }
+    constructor(adapter, registry, name, location){
+        _define_property$4(this, "name", void 0);
+        _define_property$4(this, "location", void 0);
+        _define_property$4(this, "registry", void 0);
+        _define_property$4(this, "adapter", void 0);
+        this.adapter = adapter;
+        this.registry = registry;
+        this.name = name;
+        this.location = location;
+    }
+}
+
+function _define_property$3(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+/**
+ * In-memory implementation of FjellBackendAdapter for testing.
+ * Stores entities in a nested Map: namespaceKey:type -> id -> entity data.
+ */ class MemoryFjellAdapter {
+    bucketKey(type, namespace) {
+        return `${namespace !== null && namespace !== void 0 ? namespace : this.defaultNamespace}:${type}`;
+    }
+    getBucket(type, namespace) {
+        const key = this.bucketKey(type, namespace);
+        let bucket = this.store.get(key);
+        if (!bucket) {
+            bucket = new Map();
+            this.store.set(key, bucket);
+        }
+        return bucket;
+    }
+    async initialize() {
+        this.initialized = true;
+    }
+    async dispose() {
+        this.store.clear();
+        this.initialized = false;
+    }
+    async isAvailable() {
+        return this.initialized;
+    }
+    async get(type, id, namespace) {
+        const bucket = this.getBucket(type, namespace);
+        const item = bucket.get(id);
+        return item ? {
+            ...item
+        } : undefined;
+    }
+    async getAll(type, namespace) {
+        const bucket = this.getBucket(type, namespace);
+        return Array.from(bucket.values()).map((item)=>({
+                ...item
+            }));
+    }
+    async create(type, item, namespace) {
+        const bucket = this.getBucket(type, namespace);
+        const id = item.id;
+        const stored = {
+            ...item
+        };
+        bucket.set(id, stored);
+        return {
+            ...stored
+        };
+    }
+    async update(type, id, item, namespace) {
+        const bucket = this.getBucket(type, namespace);
+        const stored = {
+            ...item
+        };
+        bucket.set(id, stored);
+        return {
+            ...stored
+        };
+    }
+    async remove(type, id, namespace) {
+        const bucket = this.getBucket(type, namespace);
+        return bucket.delete(id);
+    }
+    async find(type, filter, namespace) {
+        const all = await this.getAll(type, namespace);
+        let results = all;
+        if (filter.ids) {
+            const idSet = new Set(filter.ids);
+            results = results.filter((item)=>idSet.has(item.id));
+        }
+        if (filter.search) {
+            const term = filter.search.toLowerCase();
+            results = results.filter((item)=>{
+                var _item_name, _item_notes;
+                const name = (_item_name = item.name) !== null && _item_name !== void 0 ? _item_name : '';
+                const notes = (_item_notes = item.notes) !== null && _item_notes !== void 0 ? _item_notes : '';
+                return name.toLowerCase().includes(term) || notes.toLowerCase().includes(term);
+            });
+        }
+        if (filter.offset) {
+            results = results.slice(filter.offset);
+        }
+        if (filter.limit) {
+            results = results.slice(0, filter.limit);
+        }
+        return results;
+    }
+    async exists(type, id, namespace) {
+        const bucket = this.getBucket(type, namespace);
+        return bucket.has(id);
+    }
+    async count(type, filter, namespace) {
+        if (filter) {
+            const results = await this.find(type, filter, namespace);
+            return results.length;
+        }
+        const bucket = this.getBucket(type, namespace);
+        return bucket.size;
+    }
+    async listNamespaces() {
+        const namespaces = new Set();
+        for (const key of this.store.keys()){
+            const ns = key.split(':')[0];
+            if (this.store.get(key).size > 0) {
+                namespaces.add(ns);
+            }
+        }
+        return Array.from(namespaces);
+    }
+    async namespaceExists(namespace) {
+        for (const [key, bucket] of this.store.entries()){
+            if (key.startsWith(`${namespace}:`) && bucket.size > 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+    async listTypes(namespace) {
+        const ns = namespace !== null && namespace !== void 0 ? namespace : this.defaultNamespace;
+        const types = new Set();
+        for (const [key, bucket] of this.store.entries()){
+            if (key.startsWith(`${ns}:`) && bucket.size > 0) {
+                types.add(key.split(':')[1]);
+            }
+        }
+        return Array.from(types);
+    }
+    constructor(){
+        _define_property$3(this, "store", new Map());
+        _define_property$3(this, "initialized", false);
+        _define_property$3(this, "defaultNamespace", 'default');
+    }
+}
+
+function _define_property$2(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+/**
+ * Filesystem-backed Fjell adapter.
+ * Uses one lib-fs Library instance per namespace/type pair.
+ */ class FjellFsAdapter {
+    async initialize() {
+        await fs__namespace.mkdir(this.config.basePath, {
+            recursive: true
+        });
+        // Prime libraries for known types in the default namespace.
+        for (const type of this.config.registry.types()){
+            this.getLibrary(type);
+        }
+        this.initialized = true;
+    }
+    async dispose() {
+        this.libraries.clear();
+        this.initialized = false;
+    }
+    async isAvailable() {
+        if (!this.initialized) {
+            return false;
+        }
+        try {
+            const stat = await fs__namespace.stat(this.config.basePath);
+            return stat.isDirectory();
+        } catch  {
+            return false;
+        }
+    }
+    async get(type, id, namespace) {
+        const library = this.getLibrary(type, namespace);
+        const key = this.toPriKey(type, id);
+        const item = await library.operations.get(key);
+        if (!item) {
+            return undefined;
+        }
+        return this.normalizeFromFjell(item, type, id);
+    }
+    async getAll(type, namespace) {
+        const library = this.getLibrary(type, namespace);
+        const result = await library.operations.all();
+        return result.items.map((item)=>this.normalizeFromFjell(item, type));
+    }
+    async create(type, item, namespace) {
+        var _item_id;
+        const id = String((_item_id = item.id) !== null && _item_id !== void 0 ? _item_id : '');
+        const library = this.getLibrary(type, namespace);
+        const key = this.toPriKey(type, id);
+        const created = await library.operations.create(this.toFjellItem(type, id, item), {
+            key
+        });
+        return this.normalizeFromFjell(created, type, id);
+    }
+    async update(type, id, item, namespace) {
+        const library = this.getLibrary(type, namespace);
+        const key = this.toPriKey(type, id);
+        const updated = await library.operations.update(key, this.toFjellItem(type, id, item));
+        return this.normalizeFromFjell(updated, type, id);
+    }
+    async remove(type, id, namespace) {
+        const existing = await this.get(type, id, namespace);
+        if (!existing) {
+            return false;
+        }
+        const library = this.getLibrary(type, namespace);
+        const key = this.toPriKey(type, id);
+        await library.operations.remove(key);
+        return true;
+    }
+    async find(type, filter, namespace) {
+        let results = await this.getAll(type, namespace);
+        if (filter.ids && filter.ids.length > 0) {
+            const ids = new Set(filter.ids);
+            results = results.filter((item)=>ids.has(String(item.id)));
+        }
+        if (filter.search) {
+            const search = filter.search.toLowerCase();
+            results = results.filter((item)=>{
+                var _item_name, _item_notes;
+                const name = String((_item_name = item.name) !== null && _item_name !== void 0 ? _item_name : '').toLowerCase();
+                const notes = String((_item_notes = item.notes) !== null && _item_notes !== void 0 ? _item_notes : '').toLowerCase();
+                return name.includes(search) || notes.includes(search);
+            });
+        }
+        if (filter.offset && filter.offset > 0) {
+            results = results.slice(filter.offset);
+        }
+        if (filter.limit && filter.limit >= 0) {
+            results = results.slice(0, filter.limit);
+        }
+        return results;
+    }
+    async exists(type, id, namespace) {
+        const existing = await this.get(type, id, namespace);
+        return Boolean(existing);
+    }
+    async count(type, filter, namespace) {
+        if (!filter) {
+            const all = await this.getAll(type, namespace);
+            return all.length;
+        }
+        const results = await this.find(type, filter, namespace);
+        return results.length;
+    }
+    async listNamespaces() {
+        let entries;
+        try {
+            entries = await fs__namespace.readdir(this.config.basePath, {
+                withFileTypes: true
+            });
+        } catch  {
+            return [];
+        }
+        const knownTypes = new Set(this.config.registry.types());
+        return entries.filter((entry)=>entry.isDirectory()).map((entry)=>entry.name).filter((name)=>!knownTypes.has(name));
+    }
+    async namespaceExists(namespace) {
+        const nsPath = path__namespace.join(this.config.basePath, namespace);
+        try {
+            const stat = await fs__namespace.stat(nsPath);
+            return stat.isDirectory();
+        } catch  {
+            return false;
+        }
+    }
+    async listTypes(namespace) {
+        const ns = this.resolveNamespace(namespace);
+        const nsPath = path__namespace.join(this.config.basePath, ns);
+        let entries;
+        try {
+            entries = await fs__namespace.readdir(nsPath, {
+                withFileTypes: true
+            });
+        } catch  {
+            return [];
+        }
+        return entries.filter((entry)=>entry.isDirectory()).map((entry)=>entry.name);
+    }
+    libraryKey(type, namespace) {
+        return `${this.resolveNamespace(namespace)}:${type}`;
+    }
+    resolveNamespace(namespace) {
+        return namespace !== null && namespace !== void 0 ? namespace : this.defaultNamespace;
+    }
+    getLibrary(type, namespace) {
+        const key = this.libraryKey(type, namespace);
+        const existing = this.libraries.get(key);
+        if (existing) {
+            return existing;
+        }
+        const ns = this.resolveNamespace(namespace);
+        const library = libFs.createPrimaryFilesystemLibrary(type, `${ns}/${type}`, this.config.basePath);
+        this.libraries.set(key, library);
+        return library;
+    }
+    toPriKey(type, id) {
+        return {
+            kt: type,
+            pk: id
+        };
+    }
+    toFjellItem(type, id, item) {
+        return {
+            ...item,
+            id,
+            type
+        };
+    }
+    normalizeFromFjell(item, type, idFromKey) {
+        const raw = {
+            ...item
+        };
+        delete raw.key;
+        delete raw.events;
+        delete raw.aggs;
+        delete raw.refs;
+        const key = item.key;
+        const id = idFromKey !== null && idFromKey !== void 0 ? idFromKey : typeof raw.id === 'string' ? raw.id : key === null || key === void 0 ? void 0 : key.pk;
+        return {
+            ...raw,
+            id: id ? String(id) : '',
+            type: typeof raw.type === 'string' ? raw.type : type
+        };
+    }
+    constructor(config){
+        _define_property$2(this, "libraries", new Map());
+        _define_property$2(this, "config", void 0);
+        _define_property$2(this, "defaultNamespace", 'default');
+        _define_property$2(this, "initialized", false);
+        this.config = config;
+    }
+}
+
+async function createFjellFsProvider(config) {
+    var _config_name;
+    const adapter = new FjellFsAdapter(config);
+    const provider = new FjellStorageProvider(adapter, config.registry, (_config_name = config.name) !== null && _config_name !== void 0 ? _config_name : 'fjell-fs', config.basePath);
+    await provider.initialize();
+    return provider;
+}
+
+function _define_property$1(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+/**
+ * GCS-backed Fjell adapter.
+ * Uses one lib-gcs Library instance per namespace/type pair.
+ */ class FjellGcsAdapter {
+    async initialize() {
+        // Prime libraries for known types in the default namespace.
+        for (const type of this.config.registry.types()){
+            this.getLibrary(type);
+        }
+        this.initialized = true;
+    }
+    async dispose() {
+        this.libraries.clear();
+        this.initialized = false;
+    }
+    async isAvailable() {
+        return this.initialized;
+    }
+    async get(type, id, namespace) {
+        const library = this.getLibrary(type, namespace);
+        const key = this.toPriKey(type, id);
+        const item = await library.operations.get(key);
+        if (!item) {
+            return undefined;
+        }
+        return this.normalizeFromFjell(item, type, id);
+    }
+    async getAll(type, namespace) {
+        const library = this.getLibrary(type, namespace);
+        const result = await library.operations.all();
+        return result.items.map((item)=>this.normalizeFromFjell(item, type));
+    }
+    async create(type, item, namespace) {
+        var _item_id;
+        const id = String((_item_id = item.id) !== null && _item_id !== void 0 ? _item_id : '');
+        const library = this.getLibrary(type, namespace);
+        const key = this.toPriKey(type, id);
+        const created = await library.operations.create(this.toFjellItem(type, id, item), {
+            key
+        });
+        return this.normalizeFromFjell(created, type, id);
+    }
+    async update(type, id, item, namespace) {
+        const library = this.getLibrary(type, namespace);
+        const key = this.toPriKey(type, id);
+        const updated = await library.operations.update(key, this.toFjellItem(type, id, item));
+        return this.normalizeFromFjell(updated, type, id);
+    }
+    async remove(type, id, namespace) {
+        const existing = await this.get(type, id, namespace);
+        if (!existing) {
+            return false;
+        }
+        const library = this.getLibrary(type, namespace);
+        const key = this.toPriKey(type, id);
+        await library.operations.remove(key);
+        return true;
+    }
+    async find(type, filter, namespace) {
+        let results = await this.getAll(type, namespace);
+        if (filter.ids && filter.ids.length > 0) {
+            const ids = new Set(filter.ids);
+            results = results.filter((item)=>ids.has(String(item.id)));
+        }
+        if (filter.search) {
+            const search = filter.search.toLowerCase();
+            results = results.filter((item)=>{
+                var _item_name, _item_notes;
+                const name = String((_item_name = item.name) !== null && _item_name !== void 0 ? _item_name : '').toLowerCase();
+                const notes = String((_item_notes = item.notes) !== null && _item_notes !== void 0 ? _item_notes : '').toLowerCase();
+                return name.includes(search) || notes.includes(search);
+            });
+        }
+        if (filter.offset && filter.offset > 0) {
+            results = results.slice(filter.offset);
+        }
+        if (filter.limit && filter.limit >= 0) {
+            results = results.slice(0, filter.limit);
+        }
+        return results;
+    }
+    async exists(type, id, namespace) {
+        const existing = await this.get(type, id, namespace);
+        return Boolean(existing);
+    }
+    async count(type, filter, namespace) {
+        if (!filter) {
+            const all = await this.getAll(type, namespace);
+            return all.length;
+        }
+        const results = await this.find(type, filter, namespace);
+        return results.length;
+    }
+    async listNamespaces() {
+        const names = await this.listObjectNames(this.objectPrefix());
+        const knownTypes = new Set(this.config.registry.types());
+        const namespaces = new Set();
+        for (const name of names){
+            const rel = this.relativeObjectPath(name);
+            if (!rel) {
+                continue;
+            }
+            const [firstSegment] = rel.split('/');
+            if (!firstSegment || knownTypes.has(firstSegment)) {
+                continue;
+            }
+            namespaces.add(firstSegment);
+        }
+        return Array.from(namespaces);
+    }
+    async namespaceExists(namespace) {
+        const prefix = this.objectPrefix(namespace);
+        const names = await this.listObjectNames(prefix);
+        return names.length > 0;
+    }
+    async listTypes(namespace) {
+        const ns = this.resolveNamespace(namespace);
+        const prefix = this.objectPrefix(ns);
+        const names = await this.listObjectNames(prefix);
+        const types = new Set();
+        for (const name of names){
+            const rel = this.relativeObjectPath(name);
+            if (!rel || !rel.startsWith(`${ns}/`)) {
+                continue;
+            }
+            const parts = rel.split('/');
+            if (parts.length >= 2 && parts[1]) {
+                types.add(parts[1]);
+            }
+        }
+        return Array.from(types);
+    }
+    libraryKey(type, namespace) {
+        return `${this.resolveNamespace(namespace)}:${type}`;
+    }
+    resolveNamespace(namespace) {
+        return namespace !== null && namespace !== void 0 ? namespace : this.defaultNamespace;
+    }
+    getLibrary(type, namespace) {
+        const key = this.libraryKey(type, namespace);
+        const existing = this.libraries.get(key);
+        if (existing) {
+            return existing;
+        }
+        const ns = this.resolveNamespace(namespace);
+        const libBasePath = this.joinPath(this.normalizeBasePath(this.config.basePath), ns);
+        const library = libGcs.createPrimaryGCSLibrary(type, type, {
+            bucketName: this.config.bucketName,
+            basePath: libBasePath,
+            storage: this.config.storage,
+            useJsonExtension: true,
+            querySafety: this.config.querySafety
+        });
+        this.libraries.set(key, library);
+        return library;
+    }
+    toPriKey(type, id) {
+        return {
+            kt: type,
+            pk: id
+        };
+    }
+    toFjellItem(type, id, item) {
+        return {
+            ...item,
+            id,
+            type
+        };
+    }
+    normalizeFromFjell(item, type, idFromKey) {
+        const raw = {
+            ...item
+        };
+        delete raw.key;
+        delete raw.events;
+        delete raw.aggs;
+        delete raw.refs;
+        const key = item.key;
+        const id = idFromKey !== null && idFromKey !== void 0 ? idFromKey : typeof raw.id === 'string' ? raw.id : key === null || key === void 0 ? void 0 : key.pk;
+        return {
+            ...raw,
+            id: id ? String(id) : '',
+            type: typeof raw.type === 'string' ? raw.type : type
+        };
+    }
+    objectPrefix(...parts) {
+        const normalizedBase = this.normalizeBasePath(this.config.basePath);
+        const segments = [
+            normalizedBase,
+            ...parts
+        ].filter(Boolean);
+        return segments.length > 0 ? `${segments.join('/')}/` : '';
+    }
+    joinPath(...parts) {
+        return parts.filter(Boolean).join('/');
+    }
+    normalizeBasePath(basePath) {
+        if (!basePath) {
+            return '';
+        }
+        return basePath.replace(/^\/+|\/+$/g, '');
+    }
+    relativeObjectPath(fullName) {
+        const base = this.normalizeBasePath(this.config.basePath);
+        if (!base) {
+            return fullName;
+        }
+        return fullName.startsWith(`${base}/`) ? fullName.slice(base.length + 1) : fullName;
+    }
+    async listObjectNames(prefix) {
+        const storage = this.config.storage;
+        if (!storage) {
+            return [];
+        }
+        const bucket = storage.bucket(this.config.bucketName);
+        const [files] = await bucket.getFiles({
+            prefix
+        });
+        return files.map((file)=>{
+            var _file_name;
+            return (_file_name = file.name) !== null && _file_name !== void 0 ? _file_name : '';
+        }).filter(Boolean);
+    }
+    constructor(config){
+        _define_property$1(this, "libraries", new Map());
+        _define_property$1(this, "config", void 0);
+        _define_property$1(this, "defaultNamespace", 'default');
+        _define_property$1(this, "initialized", false);
+        this.config = config;
+    }
+}
+
+async function createFjellGcsProvider(config) {
+    var _config_name;
+    const adapter = new FjellGcsAdapter(config);
+    const location = config.basePath ? `gs://${config.bucketName}/${config.basePath}` : `gs://${config.bucketName}`;
+    const provider = new FjellStorageProvider(adapter, config.registry, (_config_name = config.name) !== null && _config_name !== void 0 ? _config_name : 'fjell-gcs', location);
+    await provider.initialize();
+    return provider;
+}
+
 /**
  * Generate a slug from a name.
  * "John Doe" -> "john-doe"
@@ -2008,6 +2800,10 @@ const discoverContextRoot = async (options = {})=>{
 exports.BaseEntitySchema = BaseEntitySchema;
 exports.EntityMetadataSchema = EntityMetadataSchema;
 exports.EntityNotFoundError = EntityNotFoundError;
+exports.FjellFsAdapter = FjellFsAdapter;
+exports.FjellGcsAdapter = FjellGcsAdapter;
+exports.FjellStorageProvider = FjellStorageProvider;
+exports.MemoryFjellAdapter = MemoryFjellAdapter;
 exports.NamespaceNotFoundError = NamespaceNotFoundError;
 exports.QueryBuilder = QueryBuilder;
 exports.ReadonlyStorageError = ReadonlyStorageError;
@@ -2021,6 +2817,8 @@ exports.createContext = createContext;
 exports.createDirectoryWalker = createDirectoryWalker;
 exports.createEntitySchema = createEntitySchema;
 exports.createFileSystemProvider = createFileSystemProvider;
+exports.createFjellFsProvider = createFjellFsProvider;
+exports.createFjellGcsProvider = createFjellGcsProvider;
 exports.createHierarchicalProvider = createHierarchicalProvider;
 exports.createMemoryProvider = createMemoryProvider;
 exports.createMultiNamespaceContext = createMultiNamespaceContext;