@objectstack/metadata 0.9.2 → 1.0.1

package/dist/loaders/memory-loader.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Memory Metadata Loader
+ *
+ * Stores metadata in memory only. Changes are lost when process restarts.
+ * Useful for testing, temporary overrides, or "dirty" edits.
+ */
+import type { MetadataLoadOptions, MetadataLoadResult, MetadataStats, MetadataLoaderContract, MetadataSaveOptions, MetadataSaveResult } from '@objectstack/spec/system';
+import type { MetadataLoader } from './loader-interface.js';
+export declare class MemoryLoader implements MetadataLoader {
+    readonly contract: MetadataLoaderContract;
+    private storage;
+    load(type: string, name: string, _options?: MetadataLoadOptions): Promise<MetadataLoadResult>;
+    loadMany<T = any>(type: string, _options?: MetadataLoadOptions): Promise<T[]>;
+    exists(type: string, name: string): Promise<boolean>;
+    stat(type: string, name: string): Promise<MetadataStats | null>;
+    list(type: string): Promise<string[]>;
+    save(type: string, name: string, data: any, _options?: MetadataSaveOptions): Promise<MetadataSaveResult>;
+}
+//# sourceMappingURL=memory-loader.d.ts.map

package/dist/loaders/memory-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-loader.d.ts","sourceRoot":"","sources":["../../src/loaders/memory-loader.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,mBAAmB,EACnB,kBAAkB,EAClB,aAAa,EACb,sBAAsB,EACtB,mBAAmB,EACnB,kBAAkB,EACnB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,qBAAa,YAAa,YAAW,cAAc;IACjD,QAAQ,CAAC,QAAQ,EAAE,sBAAsB,CASvC;IAGF,OAAO,CAAC,OAAO,CAAuC;IAEhD,IAAI,CACR,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,QAAQ,CAAC,EAAE,mBAAmB,GAC7B,OAAO,CAAC,kBAAkB,CAAC;IAgBxB,QAAQ,CAAC,CAAC,GAAG,GAAG,EACpB,IAAI,EAAE,MAAM,EACZ,QAAQ,CAAC,EAAE,mBAAmB,GAC7B,OAAO,CAAC,CAAC,EAAE,CAAC;IAMT,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAIpD,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;IAW/D,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAMrC,IAAI,CACR,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,GAAG,EACT,QAAQ,CAAC,EAAE,mBAAmB,GAC7B,OAAO,CAAC,kBAAkB,CAAC;CAa/B"}

package/dist/loaders/memory-loader.js

@@ -0,0 +1,71 @@
+/**
+ * Memory Metadata Loader
+ *
+ * Stores metadata in memory only. Changes are lost when process restarts.
+ * Useful for testing, temporary overrides, or "dirty" edits.
+ */
+export class MemoryLoader {
+    constructor() {
+        this.contract = {
+            name: 'memory',
+            protocol: 'memory',
+            capabilities: {
+                read: true,
+                write: true,
+                watch: false,
+                list: true,
+            },
+        };
+        // Storage: Type -> Name -> Data
+        this.storage = new Map();
+    }
+    async load(type, name, _options) {
+        const typeStore = this.storage.get(type);
+        const data = typeStore?.get(name);
+        if (data) {
+            return {
+                data,
+                source: 'memory',
+                format: 'json',
+                loadTime: 0,
+            };
+        }
+        return { data: null };
+    }
+    async loadMany(type, _options) {
+        const typeStore = this.storage.get(type);
+        if (!typeStore)
+            return [];
+        return Array.from(typeStore.values());
+    }
+    async exists(type, name) {
+        return this.storage.get(type)?.has(name) ?? false;
+    }
+    async stat(type, name) {
+        if (await this.exists(type, name)) {
+            return {
+                size: 0, // In-memory
+                mtime: new Date(),
+                format: 'json',
+            };
+        }
+        return null;
+    }
+    async list(type) {
+        const typeStore = this.storage.get(type);
+        if (!typeStore)
+            return [];
+        return Array.from(typeStore.keys());
+    }
+    async save(type, name, data, _options) {
+        if (!this.storage.has(type)) {
+            this.storage.set(type, new Map());
+        }
+        this.storage.get(type).set(name, data);
+        return {
+            success: true,
+            path: `memory://${type}/${name}`,
+            saveTime: 0,
+        };
+    }
+}

package/dist/loaders/remote-loader.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Remote Metadata Loader
+ *
+ * Loads metadata from an HTTP API.
+ * This loader is stateless and delegates storage to the remote server.
+ */
+import type { MetadataLoadOptions, MetadataLoadResult, MetadataStats, MetadataLoaderContract, MetadataSaveOptions, MetadataSaveResult } from '@objectstack/spec/system';
+import type { MetadataLoader } from './loader-interface.js';
+export declare class RemoteLoader implements MetadataLoader {
+    private baseUrl;
+    private authToken?;
+    readonly contract: MetadataLoaderContract;
+    constructor(baseUrl: string, authToken?: string | undefined);
+    private get headers();
+    load(type: string, name: string, _options?: MetadataLoadOptions): Promise<MetadataLoadResult>;
+    loadMany<T = any>(type: string, _options?: MetadataLoadOptions): Promise<T[]>;
+    exists(type: string, name: string): Promise<boolean>;
+    stat(type: string, name: string): Promise<MetadataStats | null>;
+    list(type: string): Promise<string[]>;
+    save(type: string, name: string, data: any, _options?: MetadataSaveOptions): Promise<MetadataSaveResult>;
+}
+//# sourceMappingURL=remote-loader.d.ts.map

package/dist/loaders/remote-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote-loader.d.ts","sourceRoot":"","sources":["../../src/loaders/remote-loader.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,mBAAmB,EACnB,kBAAkB,EAClB,aAAa,EACb,sBAAsB,EACtB,mBAAmB,EACnB,kBAAkB,EACnB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,qBAAa,YAAa,YAAW,cAAc;IAYrC,OAAO,CAAC,OAAO;IAAU,OAAO,CAAC,SAAS,CAAC;IAXvD,QAAQ,CAAC,QAAQ,EAAE,sBAAsB,CASvC;gBAEkB,OAAO,EAAE,MAAM,EAAU,SAAS,CAAC,EAAE,MAAM,YAAA;IAE/D,OAAO,KAAK,OAAO,GAKlB;IAEK,IAAI,CACR,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,QAAQ,CAAC,EAAE,mBAAmB,GAC7B,OAAO,CAAC,kBAAkB,CAAC;IA4BxB,QAAQ,CAAC,CAAC,GAAG,GAAG,EACpB,IAAI,EAAE,MAAM,EACZ,QAAQ,CAAC,EAAE,mBAAmB,GAC7B,OAAO,CAAC,CAAC,EAAE,CAAC;IAaT,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAQpD,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;IAgB/D,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAKrC,IAAI,CACR,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,GAAG,EACT,QAAQ,CAAC,EAAE,mBAAmB,GAC7B,OAAO,CAAC,kBAAkB,CAAC;CAiB/B"}

package/dist/loaders/remote-loader.js

@@ -0,0 +1,103 @@
+/**
+ * Remote Metadata Loader
+ *
+ * Loads metadata from an HTTP API.
+ * This loader is stateless and delegates storage to the remote server.
+ */
+export class RemoteLoader {
+    constructor(baseUrl, authToken) {
+        this.baseUrl = baseUrl;
+        this.authToken = authToken;
+        this.contract = {
+            name: 'remote',
+            protocol: 'http',
+            capabilities: {
+                read: true,
+                write: true,
+                watch: false, // Could implement SSE/WebSocket in future
+                list: true,
+            },
+        };
+    }
+    get headers() {
+        return {
+            'Content-Type': 'application/json',
+            ...(this.authToken ? { Authorization: `Bearer ${this.authToken}` } : {}),
+        };
+    }
+    async load(type, name, _options) {
+        try {
+            const response = await fetch(`${this.baseUrl}/${type}/${name}`, {
+                method: 'GET',
+                headers: this.headers,
+            });
+            if (response.status === 404) {
+                return { data: null };
+            }
+            if (!response.ok) {
+                throw new Error(`Remote load failed: ${response.statusText}`);
+            }
+            const data = await response.json();
+            return {
+                data,
+                source: this.baseUrl,
+                format: 'json',
+                loadTime: 0,
+            };
+        }
+        catch (error) {
+            console.error(`RemoteLoader error loading ${type}/${name}`, error);
+            throw error;
+        }
+    }
+    async loadMany(type, _options) {
+        const response = await fetch(`${this.baseUrl}/${type}`, {
+            method: 'GET',
+            headers: this.headers,
+        });
+        if (!response.ok) {
+            return [];
+        }
+        return (await response.json());
+    }
+    async exists(type, name) {
+        const response = await fetch(`${this.baseUrl}/${type}/${name}`, {
+            method: 'HEAD',
+            headers: this.headers,
+        });
+        return response.ok;
+    }
+    async stat(type, name) {
+        // Basic implementation using HEAD
+        const response = await fetch(`${this.baseUrl}/${type}/${name}`, {
+            method: 'HEAD',
+            headers: this.headers,
+        });
+        if (!response.ok)
+            return null;
+        return {
+            size: Number(response.headers.get('content-length') || 0),
+            mtime: new Date(response.headers.get('last-modified') || Date.now()),
+            format: 'json',
+        };
+    }
+    async list(type) {
+        const items = await this.loadMany(type);
+        return items.map(i => i.name);
+    }
+    async save(type, name, data, _options) {
+        const response = await fetch(`${this.baseUrl}/${type}/${name}`, {
+            method: 'PUT',
+            headers: this.headers,
+            body: JSON.stringify(data),
+        });
+        if (!response.ok) {
+            throw new Error(`Remote save failed: ${response.statusText}`);
+        }
+        return {
+            success: true,
+            path: `${this.baseUrl}/${type}/${name}`,
+            saveTime: 0,
+        };
+    }
+}

package/dist/metadata-manager.d.ts

@@ -1,35 +1,50 @@
 /**
  * Metadata Manager
  *
- * Main orchestrator for metadata loading, saving, and persistence
+ * Main orchestrator for metadata loading, saving, and persistence.
+ * Browser-compatible (Pure).
  */
-import type { MetadataManagerConfig, MetadataLoadOptions, MetadataSaveOptions, MetadataSaveResult, MetadataWatchEvent } from '@objectstack/spec/system';
+import type { MetadataManagerConfig, MetadataLoadOptions, MetadataSaveOptions, MetadataSaveResult, MetadataWatchEvent, MetadataFormat } from '@objectstack/spec/system';
+import { type Logger } from '@objectstack/core';
+import type { MetadataSerializer } from './serializers/serializer-interface.js';
+import type { MetadataLoader } from './loaders/loader-interface.js';
 /**
  * Watch callback function
  */
 export type WatchCallback = (event: MetadataWatchEvent) => void | Promise<void>;
+export interface MetadataManagerOptions extends MetadataManagerConfig {
+    loaders?: MetadataLoader[];
+}
 /**
  * Main metadata manager class
  */
 export declare class MetadataManager {
-    private config;
-    private loader;
-    private serializers;
-    private logger;
-    private watcher?;
-    private watchCallbacks;
-    constructor(config: MetadataManagerConfig);
+    private loaders;
+    protected serializers: Map<MetadataFormat, MetadataSerializer>;
+    protected logger: Logger;
+    protected watchCallbacks: Map<string, Set<WatchCallback>>;
+    protected config: MetadataManagerOptions;
+    constructor(config: MetadataManagerOptions);
+    /**
+     * Register a new metadata loader (data source)
+     */
+    registerLoader(loader: MetadataLoader): void;
     /**
      * Load a single metadata item
+     * Iterates through registered loaders until found
      */
     load<T = any>(type: string, name: string, options?: MetadataLoadOptions): Promise<T | null>;
     /**
      * Load multiple metadata items
+     * Aggregates results from all loaders
      */
     loadMany<T = any>(type: string, options?: MetadataLoadOptions): Promise<T[]>;
     /**
      * Save metadata to disk
      */
+    /**
+     * Save metadata item
+     */
     save<T = any>(type: string, name: string, data: T, options?: MetadataSaveOptions): Promise<MetadataSaveResult>;
     /**
      * Check if metadata item exists
@@ -51,19 +66,6 @@ export declare class MetadataManager {
      * Stop all watching
      */
     stopWatching(): Promise<void>;
-    /**
-     * Start watching for file changes
-     */
-    private startWatching;
-    /**
-     * Handle file change events
-     */
-    private handleFileEvent;
-    /**
-     * Generate ETag for content
-     * Uses SHA-256 hash truncated to 32 characters for reasonable collision resistance
-     * while keeping ETag headers compact (full 64-char hash is overkill for this use case)
-     */
-    private generateETag;
+    protected notifyWatchers(type: string, event: MetadataWatchEvent): void;
 }
 //# sourceMappingURL=metadata-manager.d.ts.map

package/dist/metadata-manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"metadata-manager.d.ts","sourceRoot":"","sources":["../src/metadata-manager.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,OAAO,KAAK,EACV,qBAAqB,EACrB,mBAAmB,EACnB,mBAAmB,EACnB,kBAAkB,EAClB,kBAAkB,EAEnB,MAAM,0BAA0B,CAAC;AASlC;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,KAAK,EAAE,kBAAkB,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAEhF;;GAEG;AACH,qBAAa,eAAe;IAOd,OAAO,CAAC,MAAM;IAN1B,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,WAAW,CAA0C;IAC7D,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,OAAO,CAAC,CAAY;IAC5B,OAAO,CAAC,cAAc,CAAyC;gBAE3C,MAAM,EAAE,qBAAqB;IA8BjD;;OAEG;IACG,IAAI,CAAC,CAAC,GAAG,GAAG,EAChB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,mBAAmB,GAC5B,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAKpB;;OAEG;IACG,QAAQ,CAAC,CAAC,GAAG,GAAG,EACpB,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,mBAAmB,GAC5B,OAAO,CAAC,CAAC,EAAE,CAAC;IAIf;;OAEG;IACG,IAAI,CAAC,CAAC,GAAG,GAAG,EAChB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,CAAC,EACP,OAAO,CAAC,EAAE,mBAAmB,GAC5B,OAAO,CAAC,kBAAkB,CAAC;IA2F9B;;OAEG;IACG,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAI1D;;OAEG;IACG,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAI3C;;OAEG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,aAAa,GAAG,IAAI;IAOlD;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,aAAa,GAAG,IAAI;IAUpD;;OAEG;IACG,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAQnC;;OAEG;IACH,OAAO,CAAC,aAAa;IA0BrB;;OAEG;YACW,eAAe;IAwD7B;;;;OAIG;IACH,OAAO,CAAC,YAAY;CAIrB"}
+{"version":3,"file":"metadata-manager.d.ts","sourceRoot":"","sources":["../src/metadata-manager.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,qBAAqB,EACrB,mBAAmB,EACnB,mBAAmB,EACnB,kBAAkB,EAClB,kBAAkB,EAClB,cAAc,EACf,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAgB,KAAK,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAI9D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uCAAuC,CAAC;AAChF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAEpE;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,KAAK,EAAE,kBAAkB,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAEhF,MAAM,WAAW,sBAAuB,SAAQ,qBAAqB;IACnE,OAAO,CAAC,EAAE,cAAc,EAAE,CAAC;CAC5B;AAED;;GAEG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,OAAO,CAA0C;IAEzD,SAAS,CAAC,WAAW,EAAE,GAAG,CAAC,cAAc,EAAE,kBAAkB,CAAC,CAAC;IAC/D,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,cAAc,kCAAyC;IACjE,SAAS,CAAC,MAAM,EAAE,sBAAsB,CAAC;gBAE7B,MAAM,EAAE,sBAAsB;IA4B1C;;OAEG;IACH,cAAc,CAAC,MAAM,EAAE,cAAc;IAKrC;;;OAGG;IACG,IAAI,CAAC,CAAC,GAAG,GAAG,EAChB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,mBAAmB,GAC5B,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAgBpB;;;OAGG;IACG,QAAQ,CAAC,CAAC,GAAG,GAAG,EACpB,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,mBAAmB,GAC5B,OAAO,CAAC,CAAC,EAAE,CAAC;IAiBf;;OAEG;IACH;;OAEG;IACG,IAAI,CAAC,CAAC,GAAG,GAAG,EAChB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,CAAC,EACP,OAAO,CAAC,EAAE,mBAAmB,GAC5B,OAAO,CAAC,kBAAkB,CAAC;IA0D9B;;OAEG;IACG,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAS1D;;OAEG;IACG,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAS3C;;OAEG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,aAAa,GAAG,IAAI;IAOlD;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,aAAa,GAAG,IAAI;IAUpD;;OAEG;IACG,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAInC,SAAS,CAAC,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,kBAAkB;CAejE"}

package/dist/metadata-manager.js

@@ -1,14 +1,10 @@
 /**
  * Metadata Manager
  *
- * Main orchestrator for metadata loading, saving, and persistence
+ * Main orchestrator for metadata loading, saving, and persistence.
+ * Browser-compatible (Pure).
  */
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import { createHash } from 'node:crypto';
-import { watch as chokidarWatch } from 'chokidar';
 import { createLogger } from '@objectstack/core';
-import { FilesystemLoader } from './loaders/filesystem-loader.js';
 import { JSONSerializer } from './serializers/json-serializer.js';
 import { YAMLSerializer } from './serializers/yaml-serializer.js';
 import { TypeScriptSerializer } from './serializers/typescript-serializer.js';
@@ -17,8 +13,9 @@ import { TypeScriptSerializer } from './serializers/typescript-serializer.js';
  */
 export class MetadataManager {
     constructor(config) {
-        this.config = config;
+        this.loaders = new Map();
         this.watchCallbacks = new Map();
+        this.config = config;
         this.logger = createLogger({ level: 'info', format: 'pretty' });
         // Initialize serializers
         this.serializers = new Map();
@@ -35,117 +32,138 @@ export class MetadataManager {
         if (formats.includes('javascript')) {
             this.serializers.set('javascript', new TypeScriptSerializer('javascript'));
         }
-        // Initialize loader
-        const rootDir = config.rootDir || process.cwd();
-        this.loader = new FilesystemLoader(rootDir, this.serializers, this.logger);
-        // Start watching if enabled
-        if (config.watch) {
-            this.startWatching();
+        // Initialize Loaders
+        if (config.loaders && config.loaders.length > 0) {
+            config.loaders.forEach(loader => this.registerLoader(loader));
         }
+        // Note: No default loader in base class. Subclasses (NodeMetadataManager) or caller must provide one.
+    }
+    /**
+     * Register a new metadata loader (data source)
+     */
+    registerLoader(loader) {
+        this.loaders.set(loader.contract.name, loader);
+        this.logger.info(`Registered metadata loader: ${loader.contract.name} (${loader.contract.protocol})`);
     }
     /**
      * Load a single metadata item
+     * Iterates through registered loaders until found
      */
     async load(type, name, options) {
-        const result = await this.loader.load(type, name, options);
-        return result.data;
+        // Priority: Database > Filesystem (Implementation-dependent)
+        // For now, we just iterate.
+        for (const loader of this.loaders.values()) {
+            try {
+                const result = await loader.load(type, name, options);
+                if (result.data) {
+                    return result.data;
+                }
+            }
+            catch (e) {
+                this.logger.warn(`Loader ${loader.contract.name} failed to load ${type}:${name}`, { error: e });
+            }
+        }
+        return null;
     }
     /**
      * Load multiple metadata items
+     * Aggregates results from all loaders
      */
     async loadMany(type, options) {
-        return this.loader.loadMany(type, options);
+        const results = [];
+        for (const loader of this.loaders.values()) {
+            try {
+                const items = await loader.loadMany(type, options);
+                for (const item of items) {
+                    // TODO: Deduplicate based on 'name' if property exists
+                    results.push(item);
+                }
+            }
+            catch (e) {
+                this.logger.warn(`Loader ${loader.contract.name} failed to loadMany ${type}`, { error: e });
+            }
+        }
+        return results;
     }
     /**
      * Save metadata to disk
      */
+    /**
+     * Save metadata item
+     */
     async save(type, name, data, options) {
-        const startTime = Date.now();
-        const { format = 'typescript', prettify = true, indent = 2, sortKeys = false, backup = false, overwrite = true, atomic = true, path: customPath, } = options || {};
-        try {
-            // Get serializer
-            const serializer = this.serializers.get(format);
-            if (!serializer) {
-                throw new Error(`No serializer found for format: ${format}`);
+        const targetLoader = options?.loader;
+        // Find suitable loader
+        let loader;
+        if (targetLoader) {
+            loader = this.loaders.get(targetLoader);
+            if (!loader) {
+                throw new Error(`Loader not found: ${targetLoader}`);
             }
-            // Determine file path
-            const typeDir = path.join(this.config.rootDir || process.cwd(), type);
-            const fileName = `${name}${serializer.getExtension()}`;
-            const filePath = customPath || path.join(typeDir, fileName);
-            // Check if file exists
-            if (!overwrite) {
+        }
+        else {
+            // 1. Try to find existing writable loader containing this item (Update existing)
+            for (const l of this.loaders.values()) {
+                // Skip if loader is strictly read-only
+                if (!l.save)
+                    continue;
                 try {
-                    await fs.access(filePath);
-                    throw new Error(`File already exists: ${filePath}`);
-                }
-                catch (error) {
-                    // File doesn't exist, continue
-                    if (error.code !== 'ENOENT') {
-                        throw error;
+                    if (await l.exists(type, name)) {
+                        loader = l;
+                        this.logger.info(`Updating existing metadata in loader: ${l.contract.name}`);
+                        break;
                     }
                 }
-            }
-            // Create directory if it doesn't exist
-            await fs.mkdir(path.dirname(filePath), { recursive: true });
-            // Create backup if requested
-            let backupPath;
-            if (backup) {
-                try {
-                    await fs.access(filePath);
-                    backupPath = `${filePath}.bak`;
-                    await fs.copyFile(filePath, backupPath);
-                }
-                catch {
-                    // File doesn't exist, no backup needed
+                catch (e) {
+                    // Ignore existence check errors (e.g. network down)
                 }
             }
-            // Serialize data
-            const content = serializer.serialize(data, {
-                prettify,
-                indent,
-                sortKeys,
-            });
-            // Write to disk (atomic or direct)
-            if (atomic) {
-                const tempPath = `${filePath}.tmp`;
-                await fs.writeFile(tempPath, content, 'utf-8');
-                await fs.rename(tempPath, filePath);
+            // 2. Default to 'filesystem' if available (Create new)
+            if (!loader) {
+                const fsLoader = this.loaders.get('filesystem');
+                if (fsLoader && fsLoader.save) {
+                    loader = fsLoader;
+                }
             }
-            else {
-                await fs.writeFile(filePath, content, 'utf-8');
+            // 3. Fallback to any writable loader
+            if (!loader) {
+                for (const l of this.loaders.values()) {
+                    if (l.save) {
+                        loader = l;
+                        break;
+                    }
+                }
             }
-            // Get stats
-            const stats = await fs.stat(filePath);
-            const etag = this.generateETag(content);
-            return {
-                success: true,
-                path: filePath,
-                etag,
-                size: stats.size,
-                saveTime: Date.now() - startTime,
-                backupPath,
-            };
         }
-        catch (error) {
-            this.logger.error('Failed to save metadata', undefined, {
-                type,
-                name,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            throw error;
+        if (!loader) {
+            throw new Error(`No loader available for saving type: ${type}`);
+        }
+        if (!loader.save) {
+            throw new Error(`Loader '${loader.contract?.name}' does not support saving`);
         }
+        return loader.save(type, name, data, options);
     }
     /**
      * Check if metadata item exists
      */
     async exists(type, name) {
-        return this.loader.exists(type, name);
+        for (const loader of this.loaders.values()) {
+            if (await loader.exists(type, name)) {
+                return true;
+            }
+        }
+        return false;
     }
     /**
      * List all items of a type
      */
     async list(type) {
-        return this.loader.list(type);
+        const items = new Set();
+        for (const loader of this.loaders.values()) {
+            const result = await loader.list(type);
+            result.forEach(item => items.add(item));
+        }
+        return Array.from(items);
     }
     /**
      * Watch for metadata changes
@@ -172,92 +190,22 @@ export class MetadataManager {
      * Stop all watching
      */
     async stopWatching() {
-        if (this.watcher) {
-            await this.watcher.close();
-            this.watcher = undefined;
-            this.watchCallbacks.clear();
-        }
+        // Override in subclass
     }
-    /**
-     * Start watching for file changes
-     */
-    startWatching() {
-        const rootDir = this.config.rootDir || process.cwd();
-        const { ignored = ['**/node_modules/**', '**/*.test.*'], persistent = true } = this.config.watchOptions || {};
-        this.watcher = chokidarWatch(rootDir, {
-            ignored,
-            persistent,
-            ignoreInitial: true,
-        });
-        this.watcher.on('add', async (filePath) => {
-            await this.handleFileEvent('added', filePath);
-        });
-        this.watcher.on('change', async (filePath) => {
-            await this.handleFileEvent('changed', filePath);
-        });
-        this.watcher.on('unlink', async (filePath) => {
-            await this.handleFileEvent('deleted', filePath);
-        });
-        this.logger.info('File watcher started', { rootDir });
-    }
-    /**
-     * Handle file change events
-     */
-    async handleFileEvent(eventType, filePath) {
-        const rootDir = this.config.rootDir || process.cwd();
-        const relativePath = path.relative(rootDir, filePath);
-        const parts = relativePath.split(path.sep);
-        if (parts.length < 2) {
-            return; // Not a metadata file
-        }
-        const type = parts[0];
-        const fileName = parts[parts.length - 1];
-        const name = path.basename(fileName, path.extname(fileName));
+    notifyWatchers(type, event) {
         const callbacks = this.watchCallbacks.get(type);
-        if (!callbacks || callbacks.size === 0) {
+        if (!callbacks)
             return;
-        }
-        let data = undefined;
-        if (eventType !== 'deleted') {
-            try {
-                data = await this.load(type, name, { useCache: false });
-            }
-            catch (error) {
-                this.logger.error('Failed to load changed file', undefined, {
-                    filePath,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-                return;
-            }
-        }
-        const event = {
-            type: eventType,
-            metadataType: type,
-            name,
-            path: filePath,
-            data,
-            timestamp: new Date(),
-        };
         for (const callback of callbacks) {
             try {
-                await callback(event);
+                void callback(event);
             }
             catch (error) {
                 this.logger.error('Watch callback error', undefined, {
                     type,
-                    name,
                     error: error instanceof Error ? error.message : String(error),
                 });
             }
         }
     }
-    /**
-     * Generate ETag for content
-     * Uses SHA-256 hash truncated to 32 characters for reasonable collision resistance
-     * while keeping ETag headers compact (full 64-char hash is overkill for this use case)
-     */
-    generateETag(content) {
-        const hash = createHash('sha256').update(content).digest('hex').substring(0, 32);
-        return `"${hash}"`;
-    }
 }