fix: resolve build errors in metadata package and spec protocol types

- Add 'memory:' to MetadataLoaderContract protocol enum
- Fix MetadataManagerConfig/MetadataLoaderContract to use z.input for constructor-friendly types
- Add watchOptions to system MetadataManagerConfigSchema
- Fix loader protocol values to use colon suffix convention
- Fix Date to ISO string for modifiedAt/timestamp fields
- Fix test mock protocol values, imports, and missing replaceService mock

Co-authored-by: hotlong <50353452+hotlong@users.noreply.github.com>

Author: Copilot

packages/metadata/src/loaders/filesystem-loader.ts

@@ -26,7 +26,7 @@ import type { MetadataSerializer } from '../serializers/serializer-interface.js'
 export class FilesystemLoader implements MetadataLoader {
   readonly contract: MetadataLoaderContract = {
     name: 'filesystem',
-    protocol: 'file',
+    protocol: 'file:',
     capabilities: {
       read: true,
       write: true,
@@ -224,7 +224,7 @@ export class FilesystemLoader implements MetadataLoader {
 
       return {
         size: stats.size,
-        modifiedAt: stats.mtime,
+        modifiedAt: stats.mtime.toISOString(),
         etag,
         format,
         path: filePath,

packages/metadata/src/loaders/memory-loader.ts

@@ -20,7 +20,7 @@ import type { MetadataLoader } from './loader-interface.js';
 export class MemoryLoader implements MetadataLoader {
   readonly contract: MetadataLoaderContract = {
     name: 'memory',
-    protocol: 'memory',
+    protocol: 'memory:',
     capabilities: {
       read: true,
       write: true,

packages/metadata/src/loaders/remote-loader.ts

@@ -20,7 +20,7 @@ import type { MetadataLoader } from './loader-interface.js';
 export class RemoteLoader implements MetadataLoader {
   readonly contract: MetadataLoaderContract = {
     name: 'remote',
-    protocol: 'http',
+    protocol: 'http:',
     capabilities: {
       read: true,
       write: true,

packages/metadata/src/metadata.test.ts

@@ -1,7 +1,7 @@
 // Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
 
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { MetadataManager, type MetadataManagerOptions } from './metadata-manager';
+import { MetadataManager } from './metadata-manager';
 import { MemoryLoader } from './loaders/memory-loader';
 import type { MetadataLoader } from './loaders/loader-interface';
 
@@ -109,7 +109,7 @@ describe('MetadataManager', () => {
 
     it('should throw when no writable loader is available', async () => {
       const readOnlyLoader: MetadataLoader = {
-        contract: { name: 'readonly', protocol: 'test', capabilities: { read: true, write: false, watch: false, list: true } },
+        contract: { name: 'readonly', protocol: 'memory:' as const, capabilities: { read: true, write: false, watch: false, list: true } },
         load: vi.fn().mockResolvedValue({ data: null }),
         loadMany: vi.fn().mockResolvedValue([]),
         exists: vi.fn().mockResolvedValue(false),
@@ -163,15 +163,15 @@ describe('MetadataManager', () => {
 
     it('should deduplicate across loaders', async () => {
       const loader1: MetadataLoader = {
-        contract: { name: 'l1', protocol: 'test', capabilities: { read: true, write: false, watch: false, list: true } },
+        contract: { name: 'l1', protocol: 'memory:' as const, capabilities: { read: true, write: false, watch: false, list: true } },
         load: vi.fn().mockResolvedValue({ data: null }),
         loadMany: vi.fn().mockResolvedValue([]),
         exists: vi.fn().mockResolvedValue(false),
         stat: vi.fn().mockResolvedValue(null),
         list: vi.fn().mockResolvedValue(['account', 'contact']),
       };
       const loader2: MetadataLoader = {
-        contract: { name: 'l2', protocol: 'test', capabilities: { read: true, write: false, watch: false, list: true } },
+        contract: { name: 'l2', protocol: 'memory:' as const, capabilities: { read: true, write: false, watch: false, list: true } },
         load: vi.fn().mockResolvedValue({ data: null }),
         loadMany: vi.fn().mockResolvedValue([]),
         exists: vi.fn().mockResolvedValue(false),
@@ -269,7 +269,7 @@ describe('MemoryLoader', () => {
 
   it('should have correct contract', () => {
     expect(loader.contract.name).toBe('memory');
-    expect(loader.contract.protocol).toBe('memory');
+    expect(loader.contract.protocol).toBe('memory:');
     expect(loader.contract.capabilities.read).toBe(true);
     expect(loader.contract.capabilities.write).toBe(true);
   });
@@ -356,15 +356,15 @@ describe('MetadataPlugin', () => {
   }));
 
   it('should have correct plugin metadata', async () => {
-    const { MetadataPlugin } = await import('./plugin');
+    const { MetadataPlugin } = await import('./plugin.js');
     const plugin = new MetadataPlugin({ rootDir: '/tmp/test', watch: false });
     expect(plugin.name).toBe('com.objectstack.metadata');
     expect(plugin.version).toBe('1.0.0');
     expect(plugin.type).toBe('standard');
   });
 
   it('should call init and register metadata service', async () => {
-    const { MetadataPlugin } = await import('./plugin');
+    const { MetadataPlugin } = await import('./plugin.js');
     const plugin = new MetadataPlugin({ rootDir: '/tmp/test', watch: false });
 
     const ctx = createMockPluginContext();
@@ -374,7 +374,7 @@ describe('MetadataPlugin', () => {
   });
 
   it('should call start and attempt to load metadata types', async () => {
-    const { MetadataPlugin } = await import('./plugin');
+    const { MetadataPlugin } = await import('./plugin.js');
     const plugin = new MetadataPlugin({ rootDir: '/tmp/test', watch: false });
 
     const ctx = createMockPluginContext();
@@ -390,7 +390,7 @@ describe('MetadataPlugin', () => {
 
 function createMockLoader(name: string, data: any, shouldFail = false): MetadataLoader {
   return {
-    contract: { name, protocol: 'test', capabilities: { read: true, write: false, watch: false, list: true } },
+    contract: { name, protocol: 'memory:' as const, capabilities: { read: true, write: false, watch: false, list: true } },
     load: shouldFail
       ? vi.fn().mockRejectedValue(new Error('loader failed'))
       : vi.fn().mockResolvedValue({ data }),
@@ -403,7 +403,7 @@ function createMockLoader(name: string, data: any, shouldFail = false): Metadata
 
 function createMockLoaderMany(name: string, items: any[], shouldFail = false): MetadataLoader {
   return {
-    contract: { name, protocol: 'test', capabilities: { read: true, write: false, watch: false, list: true } },
+    contract: { name, protocol: 'memory:' as const, capabilities: { read: true, write: false, watch: false, list: true } },
     load: vi.fn().mockResolvedValue({ data: null }),
     loadMany: shouldFail
       ? vi.fn().mockRejectedValue(new Error('loader failed'))
@@ -417,6 +417,7 @@ function createMockLoaderMany(name: string, items: any[], shouldFail = false): M
 function createMockPluginContext() {
   return {
     registerService: vi.fn(),
+    replaceService: vi.fn(),
     getService: vi.fn().mockReturnValue(null),
     getServices: vi.fn().mockReturnValue(new Map()),
     hook: vi.fn(),

packages/metadata/src/node-metadata-manager.ts

@@ -118,7 +118,7 @@ export class NodeMetadataManager extends MetadataManager {
       name,
       path: filePath,
       data,
-      timestamp: new Date(),
+      timestamp: new Date().toISOString(),
     };
 
     this.notifyWatchers(type, event);

packages/spec/src/kernel/metadata-loader.test.ts

@@ -386,7 +386,7 @@ describe('MetadataLoaderProtocol', () => {
     });
 
     it('should accept all valid protocols', () => {
-      const protocols = ['file:', 'http:', 's3:', 'datasource:'];
+      const protocols = ['file:', 'http:', 's3:', 'datasource:', 'memory:'];
       protocols.forEach((protocol) => {
         expect(() => MetadataLoaderContractSchema.parse({
           name: 'test', protocol, capabilities: {}, supportedFormats: ['json'],

packages/spec/src/kernel/metadata-loader.zod.ts

@@ -374,7 +374,7 @@ export const MetadataLoaderContractSchema = z.object({
   /**
    * Protocol handled by this loader (e.g. 'file:', 'http:', 's3:', 'datasource:')
    */
-  protocol: z.enum(['file:', 'http:', 's3:', 'datasource:']).describe('Protocol identifier'),
+  protocol: z.enum(['file:', 'http:', 's3:', 'datasource:', 'memory:']).describe('Protocol identifier'),
 
   /**
    * Detailed capabilities
@@ -498,6 +498,6 @@ export type MetadataLoadResult = z.infer<typeof MetadataLoadResultSchema>;
 export type MetadataSaveResult = z.infer<typeof MetadataSaveResultSchema>;
 export type MetadataWatchEvent = z.infer<typeof MetadataWatchEventSchema>;
 export type MetadataCollectionInfo = z.infer<typeof MetadataCollectionInfoSchema>;
-export type MetadataLoaderContract = z.infer<typeof MetadataLoaderContractSchema>;
-export type MetadataManagerConfig = z.infer<typeof MetadataManagerConfigSchema>;
+export type MetadataLoaderContract = z.input<typeof MetadataLoaderContractSchema>;
+export type MetadataManagerConfig = z.input<typeof MetadataManagerConfigSchema>;
 export type MetadataFallbackStrategy = z.infer<typeof MetadataFallbackStrategySchema>;

packages/spec/src/system/metadata-persistence.test.ts

@@ -229,7 +229,7 @@ describe('MetadataLoaderContractSchema', () => {
   });
 
   it('should accept all valid protocols', () => {
-    const protocols = ['file:', 'http:', 's3:', 'datasource:'];
+    const protocols = ['file:', 'http:', 's3:', 'datasource:', 'memory:'];
     protocols.forEach((protocol) => {
       expect(() => MetadataLoaderContractSchema.parse({
         name: 'test', protocol, capabilities: {},

packages/spec/src/system/metadata-persistence.zod.ts

@@ -131,7 +131,7 @@ export const MetadataStatsSchema = z.object({
  */
 export const MetadataLoaderContractSchema = z.object({
   name: z.string(),
-  protocol: z.enum(['file:', 'http:', 's3:', 'datasource:']).describe('Loader protocol identifier'),
+  protocol: z.enum(['file:', 'http:', 's3:', 'datasource:', 'memory:']).describe('Loader protocol identifier'),
   description: z.string().optional(),
   supportedFormats: z.array(z.string()).optional(),
   supportsWatch: z.boolean().optional(),
@@ -311,11 +311,19 @@ export const MetadataManagerConfigSchema = z.object({
    * Cache configuration
    */
   cache: z.boolean().optional().describe('Enable metadata caching'),
+
+  /**
+   * Watch options
+   */
+  watchOptions: z.object({
+    ignored: z.array(z.string()).optional().describe('Patterns to ignore'),
+    persistent: z.boolean().default(true).describe('Keep process running'),
+  }).optional().describe('File watcher options'),
 });
 
 export type MetadataFormat = z.infer<typeof MetadataFormatSchema>;
 export type MetadataStats = z.infer<typeof MetadataStatsSchema>;
-export type MetadataLoaderContract = z.infer<typeof MetadataLoaderContractSchema>;
+export type MetadataLoaderContract = z.input<typeof MetadataLoaderContractSchema>;
 export type MetadataLoadOptions = z.infer<typeof MetadataLoadOptionsSchema>;
 export type MetadataLoadResult = z.infer<typeof MetadataLoadResultSchema>;
 export type MetadataSaveOptions = z.infer<typeof MetadataSaveOptionsSchema>;
@@ -324,6 +332,6 @@ export type MetadataWatchEvent = z.infer<typeof MetadataWatchEventSchema>;
 export type MetadataCollectionInfo = z.infer<typeof MetadataCollectionInfoSchema>;
 export type MetadataExportOptions = z.infer<typeof MetadataExportOptionsSchema>;
 export type MetadataImportOptions = z.infer<typeof MetadataImportOptionsSchema>;
-export type MetadataManagerConfig = z.infer<typeof MetadataManagerConfigSchema>;
+export type MetadataManagerConfig = z.input<typeof MetadataManagerConfigSchema>;
 export type MetadataFallbackStrategy = z.infer<typeof MetadataFallbackStrategySchema>;
 export type MetadataSource = z.infer<typeof MetadataSourceSchema>;