@objectstack/metadata 3.3.0 → 4.0.0

package/dist/node.cjs

@@ -0,0 +1,2201 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/node.ts
+var node_exports = {};
+__export(node_exports, {
+  DatabaseLoader: () => DatabaseLoader,
+  FilesystemLoader: () => FilesystemLoader,
+  JSONSerializer: () => JSONSerializer,
+  MemoryLoader: () => MemoryLoader,
+  MetadataManager: () => MetadataManager,
+  MetadataPlugin: () => MetadataPlugin,
+  Migration: () => migration_exports,
+  NodeMetadataManager: () => NodeMetadataManager,
+  RemoteLoader: () => RemoteLoader,
+  SysMetadataObject: () => SysMetadataObject,
+  TypeScriptSerializer: () => TypeScriptSerializer,
+  YAMLSerializer: () => YAMLSerializer
+});
+module.exports = __toCommonJS(node_exports);
+
+// src/metadata-manager.ts
+var import_core = require("@objectstack/core");
+
+// src/serializers/json-serializer.ts
+var JSONSerializer = class {
+  serialize(item, options) {
+    const { prettify = true, indent = 2, sortKeys = false } = options || {};
+    if (sortKeys) {
+      const sorted = this.sortObjectKeys(item);
+      return prettify ? JSON.stringify(sorted, null, indent) : JSON.stringify(sorted);
+    }
+    return prettify ? JSON.stringify(item, null, indent) : JSON.stringify(item);
+  }
+  deserialize(content, schema) {
+    const parsed = JSON.parse(content);
+    if (schema) {
+      return schema.parse(parsed);
+    }
+    return parsed;
+  }
+  getExtension() {
+    return ".json";
+  }
+  canHandle(format) {
+    return format === "json";
+  }
+  getFormat() {
+    return "json";
+  }
+  /**
+   * Recursively sort object keys
+   */
+  sortObjectKeys(obj) {
+    if (obj === null || typeof obj !== "object") {
+      return obj;
+    }
+    if (Array.isArray(obj)) {
+      return obj.map((item) => this.sortObjectKeys(item));
+    }
+    const sorted = {};
+    const keys = Object.keys(obj).sort();
+    for (const key of keys) {
+      sorted[key] = this.sortObjectKeys(obj[key]);
+    }
+    return sorted;
+  }
+};
+
+// src/serializers/yaml-serializer.ts
+var yaml = __toESM(require("js-yaml"), 1);
+var YAMLSerializer = class {
+  serialize(item, options) {
+    const { indent = 2, sortKeys = false } = options || {};
+    return yaml.dump(item, {
+      indent,
+      sortKeys,
+      lineWidth: -1,
+      // Disable line wrapping
+      noRefs: true
+      // Disable YAML references
+    });
+  }
+  deserialize(content, schema) {
+    const parsed = yaml.load(content, { schema: yaml.JSON_SCHEMA });
+    if (schema) {
+      return schema.parse(parsed);
+    }
+    return parsed;
+  }
+  getExtension() {
+    return ".yaml";
+  }
+  canHandle(format) {
+    return format === "yaml";
+  }
+  getFormat() {
+    return "yaml";
+  }
+};
+
+// src/serializers/typescript-serializer.ts
+var TypeScriptSerializer = class {
+  constructor(format = "typescript") {
+    this.format = format;
+  }
+  serialize(item, options) {
+    const { prettify = true, indent = 2 } = options || {};
+    const jsonStr = JSON.stringify(item, null, prettify ? indent : 0);
+    if (this.format === "typescript") {
+      return `import type { ServiceObject } from '@objectstack/spec/data';
+
+export const metadata: ServiceObject = ${jsonStr};
+
+export default metadata;
+`;
+    } else {
+      return `export const metadata = ${jsonStr};
+
+export default metadata;
+`;
+    }
+  }
+  deserialize(content, schema) {
+    let objectStart = content.indexOf("export const");
+    if (objectStart === -1) {
+      objectStart = content.indexOf("export default");
+    }
+    if (objectStart === -1) {
+      throw new Error(
+        'Could not parse TypeScript/JavaScript module. Expected export pattern: "export const metadata = {...};" or "export default {...};"'
+      );
+    }
+    const braceStart = content.indexOf("{", objectStart);
+    if (braceStart === -1) {
+      throw new Error("Could not find object literal in export statement");
+    }
+    let braceCount = 0;
+    let braceEnd = -1;
+    let inString = false;
+    let stringChar = "";
+    for (let i = braceStart; i < content.length; i++) {
+      const char = content[i];
+      const prevChar = i > 0 ? content[i - 1] : "";
+      if ((char === '"' || char === "'") && prevChar !== "\\") {
+        if (!inString) {
+          inString = true;
+          stringChar = char;
+        } else if (char === stringChar) {
+          inString = false;
+          stringChar = "";
+        }
+      }
+      if (!inString) {
+        if (char === "{") braceCount++;
+        if (char === "}") {
+          braceCount--;
+          if (braceCount === 0) {
+            braceEnd = i;
+            break;
+          }
+        }
+      }
+    }
+    if (braceEnd === -1) {
+      throw new Error("Could not find matching closing brace for object literal");
+    }
+    const objectLiteral = content.substring(braceStart, braceEnd + 1);
+    try {
+      const parsed = JSON.parse(objectLiteral);
+      if (schema) {
+        return schema.parse(parsed);
+      }
+      return parsed;
+    } catch (error) {
+      throw new Error(
+        `Failed to parse object literal as JSON: ${error instanceof Error ? error.message : String(error)}. Make sure the TypeScript/JavaScript object uses JSON-compatible syntax (no functions, comments, or trailing commas).`
+      );
+    }
+  }
+  getExtension() {
+    return this.format === "typescript" ? ".ts" : ".js";
+  }
+  canHandle(format) {
+    return format === "typescript" || format === "javascript";
+  }
+  getFormat() {
+    return this.format;
+  }
+};
+
+// src/objects/sys-metadata.object.ts
+var import_data = require("@objectstack/spec/data");
+var SysMetadataObject = import_data.ObjectSchema.create({
+  namespace: "sys",
+  name: "metadata",
+  label: "System Metadata",
+  pluralLabel: "System Metadata",
+  icon: "settings",
+  isSystem: true,
+  description: "Stores platform and user-scope metadata records (objects, views, flows, etc.)",
+  fields: {
+    /** Primary Key (UUID) */
+    id: import_data.Field.text({
+      label: "ID",
+      required: true,
+      readonly: true
+    }),
+    /** Machine name — unique identifier used in code references */
+    name: import_data.Field.text({
+      label: "Name",
+      required: true,
+      searchable: true,
+      maxLength: 255
+    }),
+    /** Metadata type (e.g. "object", "view", "flow") */
+    type: import_data.Field.text({
+      label: "Metadata Type",
+      required: true,
+      searchable: true,
+      maxLength: 100
+    }),
+    /** Namespace / module grouping (e.g. "crm", "core") */
+    namespace: import_data.Field.text({
+      label: "Namespace",
+      required: false,
+      defaultValue: "default",
+      maxLength: 100
+    }),
+    /** Package that owns/delivered this metadata */
+    package_id: import_data.Field.text({
+      label: "Package ID",
+      required: false,
+      maxLength: 255
+    }),
+    /** Who manages this record: package, platform, or user */
+    managed_by: import_data.Field.select(["package", "platform", "user"], {
+      label: "Managed By",
+      required: false
+    }),
+    /** Scope: system (code), platform (admin DB), user (personal DB) */
+    scope: import_data.Field.select(["system", "platform", "user"], {
+      label: "Scope",
+      required: true,
+      defaultValue: "platform"
+    }),
+    /** JSON payload — the actual metadata configuration */
+    metadata: import_data.Field.textarea({
+      label: "Metadata",
+      required: true,
+      description: "JSON-serialized metadata payload"
+    }),
+    /** Parent metadata name for extension/override */
+    extends: import_data.Field.text({
+      label: "Extends",
+      required: false,
+      maxLength: 255
+    }),
+    /** Merge strategy when extending parent metadata */
+    strategy: import_data.Field.select(["merge", "replace"], {
+      label: "Strategy",
+      required: false,
+      defaultValue: "merge"
+    }),
+    /** Owner user ID (for user-scope items) */
+    owner: import_data.Field.text({
+      label: "Owner",
+      required: false,
+      maxLength: 255
+    }),
+    /** Lifecycle state */
+    state: import_data.Field.select(["draft", "active", "archived", "deprecated"], {
+      label: "State",
+      required: false,
+      defaultValue: "active"
+    }),
+    /** Tenant ID for multi-tenant isolation */
+    tenant_id: import_data.Field.text({
+      label: "Tenant ID",
+      required: false,
+      maxLength: 255
+    }),
+    /** Version number for optimistic concurrency */
+    version: import_data.Field.number({
+      label: "Version",
+      required: false,
+      defaultValue: 1
+    }),
+    /** Content checksum for change detection */
+    checksum: import_data.Field.text({
+      label: "Checksum",
+      required: false,
+      maxLength: 64
+    }),
+    /** Origin of this metadata record */
+    source: import_data.Field.select(["filesystem", "database", "api", "migration"], {
+      label: "Source",
+      required: false
+    }),
+    /** Classification tags (JSON array) */
+    tags: import_data.Field.textarea({
+      label: "Tags",
+      required: false,
+      description: "JSON-serialized array of classification tags"
+    }),
+    /** Audit fields */
+    created_by: import_data.Field.text({
+      label: "Created By",
+      required: false,
+      readonly: true,
+      maxLength: 255
+    }),
+    created_at: import_data.Field.datetime({
+      label: "Created At",
+      required: false,
+      readonly: true
+    }),
+    updated_by: import_data.Field.text({
+      label: "Updated By",
+      required: false,
+      maxLength: 255
+    }),
+    updated_at: import_data.Field.datetime({
+      label: "Updated At",
+      required: false
+    })
+  },
+  indexes: [
+    { fields: ["type", "name"], unique: true },
+    { fields: ["type", "scope"] },
+    { fields: ["tenant_id"] },
+    { fields: ["state"] },
+    { fields: ["namespace"] }
+  ],
+  enable: {
+    trackHistory: true,
+    searchable: false,
+    apiEnabled: true,
+    apiMethods: ["get", "list", "create", "update", "delete"],
+    trash: false
+  }
+});
+
+// src/loaders/database-loader.ts
+var DatabaseLoader = class {
+  constructor(options) {
+    this.contract = {
+      name: "database",
+      protocol: "datasource:",
+      capabilities: {
+        read: true,
+        write: true,
+        watch: false,
+        list: true
+      }
+    };
+    this.schemaReady = false;
+    this.driver = options.driver;
+    this.tableName = options.tableName ?? "sys_metadata";
+    this.tenantId = options.tenantId;
+  }
+  /**
+   * Ensure the metadata table exists.
+   * Uses IDataDriver.syncSchema with the SysMetadataObject definition
+   * to idempotently create/update the table.
+   */
+  async ensureSchema() {
+    if (this.schemaReady) return;
+    try {
+      await this.driver.syncSchema(this.tableName, {
+        ...SysMetadataObject,
+        name: this.tableName
+      });
+      this.schemaReady = true;
+    } catch {
+      this.schemaReady = true;
+    }
+  }
+  /**
+   * Build base filter conditions for queries.
+   * Always includes tenantId when configured.
+   */
+  baseFilter(type, name) {
+    const filter = { type };
+    if (name !== void 0) {
+      filter.name = name;
+    }
+    if (this.tenantId) {
+      filter.tenant_id = this.tenantId;
+    }
+    return filter;
+  }
+  /**
+   * Convert a database row to a metadata payload.
+   * Parses the JSON `metadata` column back into an object.
+   */
+  rowToData(row) {
+    if (!row || !row.metadata) return null;
+    const payload = typeof row.metadata === "string" ? JSON.parse(row.metadata) : row.metadata;
+    return payload;
+  }
+  /**
+   * Convert a database row to a MetadataRecord-like object.
+   */
+  rowToRecord(row) {
+    return {
+      id: row.id,
+      name: row.name,
+      type: row.type,
+      namespace: row.namespace ?? "default",
+      packageId: row.package_id,
+      managedBy: row.managed_by,
+      scope: row.scope ?? "platform",
+      metadata: this.rowToData(row) ?? {},
+      extends: row.extends,
+      strategy: row.strategy ?? "merge",
+      owner: row.owner,
+      state: row.state ?? "active",
+      tenantId: row.tenant_id,
+      version: row.version ?? 1,
+      checksum: row.checksum,
+      source: row.source,
+      tags: row.tags ? typeof row.tags === "string" ? JSON.parse(row.tags) : row.tags : void 0,
+      createdBy: row.created_by,
+      createdAt: row.created_at,
+      updatedBy: row.updated_by,
+      updatedAt: row.updated_at
+    };
+  }
+  // ==========================================
+  // MetadataLoader Interface Implementation
+  // ==========================================
+  async load(type, name, _options) {
+    const startTime = Date.now();
+    await this.ensureSchema();
+    try {
+      const row = await this.driver.findOne(this.tableName, {
+        object: this.tableName,
+        where: this.baseFilter(type, name)
+      });
+      if (!row) {
+        return {
+          data: null,
+          loadTime: Date.now() - startTime
+        };
+      }
+      const data = this.rowToData(row);
+      const record = this.rowToRecord(row);
+      return {
+        data,
+        source: "database",
+        format: "json",
+        etag: record.checksum,
+        loadTime: Date.now() - startTime
+      };
+    } catch {
+      return {
+        data: null,
+        loadTime: Date.now() - startTime
+      };
+    }
+  }
+  async loadMany(type, _options) {
+    await this.ensureSchema();
+    try {
+      const rows = await this.driver.find(this.tableName, {
+        object: this.tableName,
+        where: this.baseFilter(type)
+      });
+      return rows.map((row) => this.rowToData(row)).filter((data) => data !== null);
+    } catch {
+      return [];
+    }
+  }
+  async exists(type, name) {
+    await this.ensureSchema();
+    try {
+      const count = await this.driver.count(this.tableName, {
+        object: this.tableName,
+        where: this.baseFilter(type, name)
+      });
+      return count > 0;
+    } catch {
+      return false;
+    }
+  }
+  async stat(type, name) {
+    await this.ensureSchema();
+    try {
+      const row = await this.driver.findOne(this.tableName, {
+        object: this.tableName,
+        where: this.baseFilter(type, name)
+      });
+      if (!row) return null;
+      const record = this.rowToRecord(row);
+      const metadataStr = typeof row.metadata === "string" ? row.metadata : JSON.stringify(row.metadata);
+      return {
+        size: metadataStr.length,
+        mtime: record.updatedAt ?? record.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+        format: "json",
+        etag: record.checksum
+      };
+    } catch {
+      return null;
+    }
+  }
+  async list(type) {
+    await this.ensureSchema();
+    try {
+      const rows = await this.driver.find(this.tableName, {
+        object: this.tableName,
+        where: this.baseFilter(type),
+        fields: ["name"]
+      });
+      return rows.map((row) => row.name).filter((name) => typeof name === "string");
+    } catch {
+      return [];
+    }
+  }
+  async save(type, name, data, _options) {
+    const startTime = Date.now();
+    await this.ensureSchema();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const metadataJson = JSON.stringify(data);
+    try {
+      const existing = await this.driver.findOne(this.tableName, {
+        object: this.tableName,
+        where: this.baseFilter(type, name)
+      });
+      if (existing) {
+        const version = (existing.version ?? 0) + 1;
+        await this.driver.update(this.tableName, existing.id, {
+          metadata: metadataJson,
+          version,
+          updated_at: now,
+          state: "active"
+        });
+        return {
+          success: true,
+          path: `datasource://${this.tableName}/${type}/${name}`,
+          size: metadataJson.length,
+          saveTime: Date.now() - startTime
+        };
+      } else {
+        const id = generateId();
+        await this.driver.create(this.tableName, {
+          id,
+          name,
+          type,
+          namespace: "default",
+          scope: data?.scope ?? "platform",
+          metadata: metadataJson,
+          strategy: "merge",
+          state: "active",
+          version: 1,
+          source: "database",
+          ...this.tenantId ? { tenant_id: this.tenantId } : {},
+          created_at: now,
+          updated_at: now
+        });
+        return {
+          success: true,
+          path: `datasource://${this.tableName}/${type}/${name}`,
+          size: metadataJson.length,
+          saveTime: Date.now() - startTime
+        };
+      }
+    } catch (error) {
+      throw new Error(
+        `DatabaseLoader save failed for ${type}/${name}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+};
+function generateId() {
+  if (typeof globalThis.crypto !== "undefined" && typeof globalThis.crypto.randomUUID === "function") {
+    return globalThis.crypto.randomUUID();
+  }
+  return `meta_${Date.now()}_${Math.random().toString(36).substring(2, 10)}`;
+}
+
+// src/metadata-manager.ts
+var MetadataManager = class {
+  constructor(config) {
+    this.loaders = /* @__PURE__ */ new Map();
+    this.watchCallbacks = /* @__PURE__ */ new Map();
+    // In-memory metadata registry: type -> name -> data
+    this.registry = /* @__PURE__ */ new Map();
+    // Overlay storage: "type:name:scope" -> MetadataOverlay
+    this.overlays = /* @__PURE__ */ new Map();
+    // Type registry for metadata type info
+    this.typeRegistry = [];
+    // Dependency tracking: "type:name" -> dependencies
+    this.dependencies = /* @__PURE__ */ new Map();
+    this.config = config;
+    this.logger = (0, import_core.createLogger)({ level: "info", format: "pretty" });
+    this.serializers = /* @__PURE__ */ new Map();
+    const formats = config.formats || ["typescript", "json", "yaml"];
+    if (formats.includes("json")) {
+      this.serializers.set("json", new JSONSerializer());
+    }
+    if (formats.includes("yaml")) {
+      this.serializers.set("yaml", new YAMLSerializer());
+    }
+    if (formats.includes("typescript")) {
+      this.serializers.set("typescript", new TypeScriptSerializer("typescript"));
+    }
+    if (formats.includes("javascript")) {
+      this.serializers.set("javascript", new TypeScriptSerializer("javascript"));
+    }
+    if (config.loaders && config.loaders.length > 0) {
+      config.loaders.forEach((loader) => this.registerLoader(loader));
+    }
+    if (config.datasource && config.driver) {
+      this.setDatabaseDriver(config.driver);
+    }
+  }
+  /**
+   * Set the type registry for metadata type discovery.
+   */
+  setTypeRegistry(entries) {
+    this.typeRegistry = entries;
+  }
+  /**
+   * Configure and register a DatabaseLoader for database-backed metadata persistence.
+   * Can be called at any time to enable database storage (e.g. after kernel resolves the driver).
+   *
+   * @param driver - An IDataDriver instance for database operations
+   */
+  setDatabaseDriver(driver) {
+    const tableName = this.config.tableName ?? "sys_metadata";
+    const dbLoader = new DatabaseLoader({
+      driver,
+      tableName
+    });
+    this.registerLoader(dbLoader);
+    this.logger.info("DatabaseLoader configured", { datasource: this.config.datasource, tableName });
+  }
+  /**
+   * 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})`);
+  }
+  // ==========================================
+  // IMetadataService — Core CRUD Operations
+  // ==========================================
+  /**
+   * Register/save a metadata item by type
+   */
+  async register(type, name, data) {
+    if (!this.registry.has(type)) {
+      this.registry.set(type, /* @__PURE__ */ new Map());
+    }
+    this.registry.get(type).set(name, data);
+  }
+  /**
+   * Get a metadata item by type and name.
+   * Checks in-memory registry first, then falls back to loaders.
+   */
+  async get(type, name) {
+    const typeStore = this.registry.get(type);
+    if (typeStore?.has(name)) {
+      return typeStore.get(name);
+    }
+    const result = await this.load(type, name);
+    return result ?? void 0;
+  }
+  /**
+   * List all metadata items of a given type
+   */
+  async list(type) {
+    const items = /* @__PURE__ */ new Map();
+    const typeStore = this.registry.get(type);
+    if (typeStore) {
+      for (const [name, data] of typeStore) {
+        items.set(name, data);
+      }
+    }
+    for (const loader of this.loaders.values()) {
+      try {
+        const loaderItems = await loader.loadMany(type);
+        for (const item of loaderItems) {
+          const itemAny = item;
+          if (itemAny && typeof itemAny.name === "string" && !items.has(itemAny.name)) {
+            items.set(itemAny.name, item);
+          }
+        }
+      } catch (e) {
+        this.logger.warn(`Loader ${loader.contract.name} failed to loadMany ${type}`, { error: e });
+      }
+    }
+    return Array.from(items.values());
+  }
+  /**
+   * Unregister/remove a metadata item by type and name
+   */
+  async unregister(type, name) {
+    const typeStore = this.registry.get(type);
+    if (typeStore) {
+      typeStore.delete(name);
+      if (typeStore.size === 0) {
+        this.registry.delete(type);
+      }
+    }
+  }
+  /**
+   * Check if a metadata item exists
+   */
+  async exists(type, name) {
+    if (this.registry.get(type)?.has(name)) {
+      return true;
+    }
+    for (const loader of this.loaders.values()) {
+      if (await loader.exists(type, name)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * List all names of metadata items of a given type
+   */
+  async listNames(type) {
+    const names = /* @__PURE__ */ new Set();
+    const typeStore = this.registry.get(type);
+    if (typeStore) {
+      for (const name of typeStore.keys()) {
+        names.add(name);
+      }
+    }
+    for (const loader of this.loaders.values()) {
+      const result = await loader.list(type);
+      result.forEach((item) => names.add(item));
+    }
+    return Array.from(names);
+  }
+  /**
+   * Convenience: get an object definition by name
+   */
+  async getObject(name) {
+    return this.get("object", name);
+  }
+  /**
+   * Convenience: list all object definitions
+   */
+  async listObjects() {
+    return this.list("object");
+  }
+  // ==========================================
+  // Convenience: UI Metadata
+  // ==========================================
+  /**
+   * Convenience: get a view definition by name
+   */
+  async getView(name) {
+    return this.get("view", name);
+  }
+  /**
+   * Convenience: list view definitions, optionally filtered by object
+   */
+  async listViews(object) {
+    const views = await this.list("view");
+    if (object) {
+      return views.filter((v) => v?.object === object);
+    }
+    return views;
+  }
+  /**
+   * Convenience: get a dashboard definition by name
+   */
+  async getDashboard(name) {
+    return this.get("dashboard", name);
+  }
+  /**
+   * Convenience: list all dashboard definitions
+   */
+  async listDashboards() {
+    return this.list("dashboard");
+  }
+  // ==========================================
+  // Package Management
+  // ==========================================
+  /**
+   * Unregister all metadata items from a specific package
+   */
+  async unregisterPackage(packageName) {
+    for (const [type, typeStore] of this.registry) {
+      const toDelete = [];
+      for (const [name, data] of typeStore) {
+        const meta = data;
+        if (meta?.packageId === packageName || meta?.package === packageName) {
+          toDelete.push(name);
+        }
+      }
+      for (const name of toDelete) {
+        typeStore.delete(name);
+      }
+      if (typeStore.size === 0) {
+        this.registry.delete(type);
+      }
+    }
+  }
+  /**
+   * Publish an entire package:
+   * 1. Validate all draft items
+   * 2. Snapshot all items in the package (publishedDefinition = clone(metadata))
+   * 3. Increment version
+   * 4. Set all items state → active
+   */
+  async publishPackage(packageId, options) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const shouldValidate = options?.validate !== false;
+    const publishedBy = options?.publishedBy;
+    const packageItems = [];
+    for (const [type, typeStore] of this.registry) {
+      for (const [name, data] of typeStore) {
+        const meta = data;
+        if (meta?.packageId === packageId || meta?.package === packageId) {
+          packageItems.push({ type, name, data: meta });
+        }
+      }
+    }
+    if (packageItems.length === 0) {
+      return {
+        success: false,
+        packageId,
+        version: 0,
+        publishedAt: now,
+        itemsPublished: 0,
+        validationErrors: [{ type: "", name: "", message: `No metadata items found for package '${packageId}'` }]
+      };
+    }
+    if (shouldValidate) {
+      const validationErrors = [];
+      for (const item of packageItems) {
+        const result = await this.validate(item.type, item.data);
+        if (!result.valid && result.errors) {
+          for (const err of result.errors) {
+            validationErrors.push({
+              type: item.type,
+              name: item.name,
+              message: err.message
+            });
+          }
+        }
+      }
+      const packageItemKeys = new Set(packageItems.map((i) => `${i.type}:${i.name}`));
+      for (const item of packageItems) {
+        const deps = await this.getDependencies(item.type, item.name);
+        for (const dep of deps) {
+          const depKey = `${dep.targetType}:${dep.targetName}`;
+          if (packageItemKeys.has(depKey)) continue;
+          const depItem = await this.get(dep.targetType, dep.targetName);
+          if (!depItem) {
+            validationErrors.push({
+              type: item.type,
+              name: item.name,
+              message: `Dependency '${dep.targetType}:${dep.targetName}' not found`
+            });
+          } else {
+            const depMeta = depItem;
+            if (depMeta.publishedDefinition === void 0 && depMeta.state !== "active") {
+              validationErrors.push({
+                type: item.type,
+                name: item.name,
+                message: `Dependency '${dep.targetType}:${dep.targetName}' is not published`
+              });
+            }
+          }
+        }
+      }
+      if (validationErrors.length > 0) {
+        return {
+          success: false,
+          packageId,
+          version: 0,
+          publishedAt: now,
+          itemsPublished: 0,
+          validationErrors
+        };
+      }
+    }
+    let maxVersion = 0;
+    for (const item of packageItems) {
+      const v = typeof item.data.version === "number" ? item.data.version : 0;
+      if (v > maxVersion) maxVersion = v;
+    }
+    const newVersion = maxVersion + 1;
+    for (const item of packageItems) {
+      const updated = {
+        ...item.data,
+        publishedDefinition: structuredClone(item.data.metadata ?? item.data),
+        publishedAt: now,
+        publishedBy: publishedBy ?? item.data.publishedBy,
+        version: newVersion,
+        state: "active"
+      };
+      await this.register(item.type, item.name, updated);
+    }
+    return {
+      success: true,
+      packageId,
+      version: newVersion,
+      publishedAt: now,
+      itemsPublished: packageItems.length
+    };
+  }
+  /**
+   * Revert entire package to last published state.
+   * Restores all metadata definitions from their published snapshots.
+   */
+  async revertPackage(packageId) {
+    const packageItems = [];
+    for (const [type, typeStore] of this.registry) {
+      for (const [name, data] of typeStore) {
+        const meta = data;
+        if (meta?.packageId === packageId || meta?.package === packageId) {
+          packageItems.push({ type, name, data: meta });
+        }
+      }
+    }
+    if (packageItems.length === 0) {
+      throw new Error(`No metadata items found for package '${packageId}'`);
+    }
+    const hasPublished = packageItems.some((item) => item.data.publishedDefinition !== void 0);
+    if (!hasPublished) {
+      throw new Error(`Package '${packageId}' has never been published`);
+    }
+    for (const item of packageItems) {
+      if (item.data.publishedDefinition !== void 0) {
+        const reverted = {
+          ...item.data,
+          metadata: structuredClone(item.data.publishedDefinition),
+          state: "active"
+        };
+        await this.register(item.type, item.name, reverted);
+      }
+    }
+  }
+  /**
+   * Get the published version of any metadata item (for runtime serving).
+   * Returns publishedDefinition if exists, else current definition.
+   */
+  async getPublished(type, name) {
+    const item = await this.get(type, name);
+    if (!item) return void 0;
+    const meta = item;
+    if (meta.publishedDefinition !== void 0) {
+      return meta.publishedDefinition;
+    }
+    return meta.metadata ?? item;
+  }
+  // ==========================================
+  // Query / Search
+  // ==========================================
+  /**
+   * Query metadata items with filtering, sorting, and pagination
+   */
+  async query(query) {
+    const { types, search, page = 1, pageSize = 50, sortBy = "name", sortOrder = "asc" } = query;
+    const allItems = [];
+    const targetTypes = types && types.length > 0 ? types : Array.from(this.registry.keys());
+    for (const type of targetTypes) {
+      const items = await this.list(type);
+      for (const item of items) {
+        const meta = item;
+        allItems.push({
+          type,
+          name: meta?.name ?? "",
+          namespace: meta?.namespace,
+          label: meta?.label,
+          scope: meta?.scope,
+          state: meta?.state,
+          packageId: meta?.packageId,
+          updatedAt: meta?.updatedAt
+        });
+      }
+    }
+    let filtered = allItems;
+    if (search) {
+      const searchLower = search.toLowerCase();
+      filtered = filtered.filter(
+        (item) => item.name.toLowerCase().includes(searchLower) || item.label && item.label.toLowerCase().includes(searchLower)
+      );
+    }
+    if (query.scope) {
+      filtered = filtered.filter((item) => item.scope === query.scope);
+    }
+    if (query.state) {
+      filtered = filtered.filter((item) => item.state === query.state);
+    }
+    if (query.namespaces && query.namespaces.length > 0) {
+      filtered = filtered.filter((item) => item.namespace && query.namespaces.includes(item.namespace));
+    }
+    if (query.packageId) {
+      filtered = filtered.filter((item) => item.packageId === query.packageId);
+    }
+    if (query.tags && query.tags.length > 0) {
+      filtered = filtered.filter((item) => {
+        const meta = item;
+        return meta?.tags && query.tags.some((t) => meta.tags.includes(t));
+      });
+    }
+    filtered.sort((a, b) => {
+      const aVal = a[sortBy] ?? "";
+      const bVal = b[sortBy] ?? "";
+      const cmp = String(aVal).localeCompare(String(bVal));
+      return sortOrder === "desc" ? -cmp : cmp;
+    });
+    const total = filtered.length;
+    const start = (page - 1) * pageSize;
+    const paged = filtered.slice(start, start + pageSize);
+    return {
+      items: paged,
+      total,
+      page,
+      pageSize
+    };
+  }
+  // ==========================================
+  // Bulk Operations
+  // ==========================================
+  /**
+   * Register multiple metadata items in a single batch
+   */
+  async bulkRegister(items, options) {
+    const { continueOnError = false } = options ?? {};
+    let succeeded = 0;
+    let failed = 0;
+    const errors = [];
+    for (const item of items) {
+      try {
+        await this.register(item.type, item.name, item.data);
+        succeeded++;
+      } catch (e) {
+        failed++;
+        errors.push({
+          type: item.type,
+          name: item.name,
+          error: e instanceof Error ? e.message : String(e)
+        });
+        if (!continueOnError) break;
+      }
+    }
+    return {
+      total: items.length,
+      succeeded,
+      failed,
+      errors: errors.length > 0 ? errors : void 0
+    };
+  }
+  /**
+   * Unregister multiple metadata items in a single batch
+   */
+  async bulkUnregister(items) {
+    let succeeded = 0;
+    let failed = 0;
+    const errors = [];
+    for (const item of items) {
+      try {
+        await this.unregister(item.type, item.name);
+        succeeded++;
+      } catch (e) {
+        failed++;
+        errors.push({
+          type: item.type,
+          name: item.name,
+          error: e instanceof Error ? e.message : String(e)
+        });
+      }
+    }
+    return {
+      total: items.length,
+      succeeded,
+      failed,
+      errors: errors.length > 0 ? errors : void 0
+    };
+  }
+  // ==========================================
+  // Overlay / Customization Management
+  // ==========================================
+  overlayKey(type, name, scope = "platform") {
+    return `${encodeURIComponent(type)}:${encodeURIComponent(name)}:${scope}`;
+  }
+  /**
+   * Get the active overlay for a metadata item
+   */
+  async getOverlay(type, name, scope) {
+    return this.overlays.get(this.overlayKey(type, name, scope ?? "platform"));
+  }
+  /**
+   * Save/update an overlay for a metadata item
+   */
+  async saveOverlay(overlay) {
+    const key = this.overlayKey(overlay.baseType, overlay.baseName, overlay.scope);
+    this.overlays.set(key, overlay);
+  }
+  /**
+   * Remove an overlay, reverting to the base definition
+   */
+  async removeOverlay(type, name, scope) {
+    this.overlays.delete(this.overlayKey(type, name, scope ?? "platform"));
+  }
+  /**
+   * Get the effective (merged) metadata after applying all overlays.
+   * Resolution order: system ← merge(platform) ← merge(user)
+   */
+  async getEffective(type, name, context) {
+    const base = await this.get(type, name);
+    if (!base) return void 0;
+    let effective = { ...base };
+    const platformOverlay = await this.getOverlay(type, name, "platform");
+    if (platformOverlay?.active && platformOverlay.patch) {
+      effective = { ...effective, ...platformOverlay.patch };
+    }
+    if (context?.userId) {
+      const userOverlayKey = this.overlayKey(type, name, "user") + `:${context.userId}`;
+      const userOverlay = this.overlays.get(userOverlayKey) ?? await this.getOverlay(type, name, "user");
+      if (userOverlay?.active && userOverlay.patch) {
+        if (!userOverlay.owner || userOverlay.owner === context.userId) {
+          effective = { ...effective, ...userOverlay.patch };
+        }
+      }
+    } else {
+      const userOverlay = await this.getOverlay(type, name, "user");
+      if (userOverlay?.active && userOverlay.patch && !userOverlay.owner) {
+        effective = { ...effective, ...userOverlay.patch };
+      }
+    }
+    return effective;
+  }
+  // ==========================================
+  // Watch / Subscribe (IMetadataService)
+  // ==========================================
+  /**
+   * Watch for metadata changes (IMetadataService contract).
+   * Returns a handle for unsubscribing.
+   */
+  watchService(type, callback) {
+    const wrappedCallback = (event) => {
+      const mappedType = event.type === "added" ? "registered" : event.type === "deleted" ? "unregistered" : "updated";
+      callback({
+        type: mappedType,
+        metadataType: event.metadataType ?? type,
+        name: event.name ?? "",
+        data: event.data
+      });
+    };
+    this.addWatchCallback(type, wrappedCallback);
+    return {
+      unsubscribe: () => this.removeWatchCallback(type, wrappedCallback)
+    };
+  }
+  // ==========================================
+  // Import / Export
+  // ==========================================
+  /**
+   * Export metadata as a portable bundle
+   */
+  async exportMetadata(options) {
+    const bundle = {};
+    const targetTypes = options?.types ?? Array.from(this.registry.keys());
+    for (const type of targetTypes) {
+      const items = await this.list(type);
+      if (items.length > 0) {
+        bundle[type] = items;
+      }
+    }
+    return bundle;
+  }
+  /**
+   * Import metadata from a portable bundle
+   */
+  async importMetadata(data, options) {
+    const {
+      conflictResolution = "skip",
+      validate: _validate = true,
+      dryRun = false
+    } = options ?? {};
+    const bundle = data;
+    let total = 0;
+    let imported = 0;
+    let skipped = 0;
+    let failed = 0;
+    const errors = [];
+    for (const [type, items] of Object.entries(bundle)) {
+      if (!Array.isArray(items)) continue;
+      for (const item of items) {
+        total++;
+        const meta = item;
+        const name = meta?.name;
+        if (!name) {
+          failed++;
+          errors.push({ type, name: "(unknown)", error: "Item missing name field" });
+          continue;
+        }
+        try {
+          const itemExists = await this.exists(type, name);
+          if (itemExists && conflictResolution === "skip") {
+            skipped++;
+            continue;
+          }
+          if (!dryRun) {
+            if (itemExists && conflictResolution === "merge") {
+              const existing = await this.get(type, name);
+              const merged = { ...existing, ...item };
+              await this.register(type, name, merged);
+            } else {
+              await this.register(type, name, item);
+            }
+          }
+          imported++;
+        } catch (e) {
+          failed++;
+          errors.push({
+            type,
+            name,
+            error: e instanceof Error ? e.message : String(e)
+          });
+        }
+      }
+    }
+    return {
+      total,
+      imported,
+      skipped,
+      failed,
+      errors: errors.length > 0 ? errors : void 0
+    };
+  }
+  // ==========================================
+  // Validation
+  // ==========================================
+  /**
+   * Validate a metadata item against its type schema.
+   * Returns validation result with errors and warnings.
+   */
+  async validate(_type, data) {
+    if (data === null || data === void 0) {
+      return {
+        valid: false,
+        errors: [{ path: "", message: "Metadata data cannot be null or undefined" }]
+      };
+    }
+    if (typeof data !== "object") {
+      return {
+        valid: false,
+        errors: [{ path: "", message: "Metadata data must be an object" }]
+      };
+    }
+    const meta = data;
+    const warnings = [];
+    if (!meta.name) {
+      return {
+        valid: false,
+        errors: [{ path: "name", message: "Metadata item must have a name field" }]
+      };
+    }
+    if (!meta.label) {
+      warnings.push({ path: "label", message: "Missing label field (recommended)" });
+    }
+    return { valid: true, warnings: warnings.length > 0 ? warnings : void 0 };
+  }
+  // ==========================================
+  // Type Registry
+  // ==========================================
+  /**
+   * Get all registered metadata types
+   */
+  async getRegisteredTypes() {
+    const types = /* @__PURE__ */ new Set();
+    for (const entry of this.typeRegistry) {
+      types.add(entry.type);
+    }
+    for (const type of this.registry.keys()) {
+      types.add(type);
+    }
+    return Array.from(types);
+  }
+  /**
+   * Get detailed information about a metadata type
+   */
+  async getTypeInfo(type) {
+    const entry = this.typeRegistry.find((e) => e.type === type);
+    if (!entry) return void 0;
+    return {
+      type: entry.type,
+      label: entry.label,
+      description: entry.description,
+      filePatterns: entry.filePatterns,
+      supportsOverlay: entry.supportsOverlay,
+      domain: entry.domain
+    };
+  }
+  // ==========================================
+  // Dependency Tracking
+  // ==========================================
+  /**
+   * Get metadata items that this item depends on
+   */
+  async getDependencies(type, name) {
+    return this.dependencies.get(`${encodeURIComponent(type)}:${encodeURIComponent(name)}`) ?? [];
+  }
+  /**
+   * Get metadata items that depend on this item
+   */
+  async getDependents(type, name) {
+    const dependents = [];
+    for (const deps of this.dependencies.values()) {
+      for (const dep of deps) {
+        if (dep.targetType === type && dep.targetName === name) {
+          dependents.push(dep);
+        }
+      }
+    }
+    return dependents;
+  }
+  /**
+   * Register a dependency between two metadata items.
+   * Used internally to track cross-references.
+   * Duplicate dependencies (same source, target, and kind) are ignored.
+   */
+  addDependency(dep) {
+    const key = `${encodeURIComponent(dep.sourceType)}:${encodeURIComponent(dep.sourceName)}`;
+    if (!this.dependencies.has(key)) {
+      this.dependencies.set(key, []);
+    }
+    const existing = this.dependencies.get(key);
+    const isDuplicate = existing.some(
+      (d) => d.targetType === dep.targetType && d.targetName === dep.targetName && d.kind === dep.kind
+    );
+    if (!isDuplicate) {
+      existing.push(dep);
+    }
+  }
+  // ==========================================
+  // Legacy Loader API (backward compatible)
+  // ==========================================
+  /**
+   * Load a single metadata item from loaders.
+   * Iterates through registered loaders until found.
+   */
+  async load(type, name, options) {
+    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 from loaders.
+   * Aggregates results from all loaders.
+   */
+  async 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) {
+          const itemAny = item;
+          if (itemAny && typeof itemAny.name === "string") {
+            const exists = results.some((r) => r && r.name === itemAny.name);
+            if (exists) continue;
+          }
+          results.push(item);
+        }
+      } catch (e) {
+        this.logger.warn(`Loader ${loader.contract.name} failed to loadMany ${type}`, { error: e });
+      }
+    }
+    return results;
+  }
+  /**
+   * Save metadata item to a loader
+   */
+  async save(type, name, data, options) {
+    const targetLoader = options?.loader;
+    let loader;
+    if (targetLoader) {
+      loader = this.loaders.get(targetLoader);
+      if (!loader) {
+        throw new Error(`Loader not found: ${targetLoader}`);
+      }
+    } else {
+      for (const l of this.loaders.values()) {
+        if (!l.save) continue;
+        try {
+          if (await l.exists(type, name)) {
+            loader = l;
+            this.logger.info(`Updating existing metadata in loader: ${l.contract.name}`);
+            break;
+          }
+        } catch (e) {
+        }
+      }
+      if (!loader) {
+        const fsLoader = this.loaders.get("filesystem");
+        if (fsLoader && fsLoader.save) {
+          loader = fsLoader;
+        }
+      }
+      if (!loader) {
+        for (const l of this.loaders.values()) {
+          if (l.save) {
+            loader = l;
+            break;
+          }
+        }
+      }
+    }
+    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);
+  }
+  /**
+   * Register a watch callback for metadata changes
+   */
+  addWatchCallback(type, callback) {
+    if (!this.watchCallbacks.has(type)) {
+      this.watchCallbacks.set(type, /* @__PURE__ */ new Set());
+    }
+    this.watchCallbacks.get(type).add(callback);
+  }
+  /**
+   * Remove a watch callback for metadata changes
+   */
+  removeWatchCallback(type, callback) {
+    const callbacks = this.watchCallbacks.get(type);
+    if (callbacks) {
+      callbacks.delete(callback);
+      if (callbacks.size === 0) {
+        this.watchCallbacks.delete(type);
+      }
+    }
+  }
+  /**
+   * Stop all watching
+   */
+  async stopWatching() {
+  }
+  notifyWatchers(type, event) {
+    const callbacks = this.watchCallbacks.get(type);
+    if (!callbacks) return;
+    for (const callback of callbacks) {
+      try {
+        void callback(event);
+      } catch (error) {
+        this.logger.error("Watch callback error", void 0, {
+          type,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  }
+};
+
+// src/node-metadata-manager.ts
+var path2 = __toESM(require("path"), 1);
+var import_chokidar = require("chokidar");
+
+// src/loaders/filesystem-loader.ts
+var fs = __toESM(require("fs/promises"), 1);
+var path = __toESM(require("path"), 1);
+var import_glob = require("glob");
+var import_node_crypto = require("crypto");
+var FilesystemLoader = class {
+  constructor(rootDir, serializers, logger) {
+    this.rootDir = rootDir;
+    this.serializers = serializers;
+    this.logger = logger;
+    this.contract = {
+      name: "filesystem",
+      protocol: "file:",
+      capabilities: {
+        read: true,
+        write: true,
+        watch: true,
+        list: true
+      },
+      supportedFormats: ["json", "yaml", "typescript", "javascript"],
+      supportsWatch: true,
+      supportsWrite: true,
+      supportsCache: true
+    };
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  async load(type, name, options) {
+    const startTime = Date.now();
+    const { validate: _validate = true, useCache = true, ifNoneMatch } = options || {};
+    try {
+      const filePath = await this.findFile(type, name);
+      if (!filePath) {
+        return {
+          data: null,
+          fromCache: false,
+          notModified: false,
+          loadTime: Date.now() - startTime
+        };
+      }
+      const stats = await this.stat(type, name);
+      if (!stats) {
+        return {
+          data: null,
+          fromCache: false,
+          notModified: false,
+          loadTime: Date.now() - startTime
+        };
+      }
+      if (useCache && ifNoneMatch && stats.etag === ifNoneMatch) {
+        return {
+          data: null,
+          fromCache: true,
+          notModified: true,
+          etag: stats.etag,
+          stats,
+          loadTime: Date.now() - startTime
+        };
+      }
+      const cacheKey = `${type}:${name}`;
+      if (useCache && this.cache.has(cacheKey)) {
+        const cached = this.cache.get(cacheKey);
+        if (cached.etag === stats.etag) {
+          return {
+            data: cached.data,
+            fromCache: true,
+            notModified: false,
+            etag: stats.etag,
+            stats,
+            loadTime: Date.now() - startTime
+          };
+        }
+      }
+      const content = await fs.readFile(filePath, "utf-8");
+      const serializer = this.getSerializer(stats.format);
+      if (!serializer) {
+        throw new Error(`No serializer found for format: ${stats.format}`);
+      }
+      const data = serializer.deserialize(content);
+      if (useCache) {
+        this.cache.set(cacheKey, {
+          data,
+          etag: stats.etag || "",
+          timestamp: Date.now()
+        });
+      }
+      return {
+        data,
+        fromCache: false,
+        notModified: false,
+        etag: stats.etag,
+        stats,
+        loadTime: Date.now() - startTime
+      };
+    } catch (error) {
+      this.logger?.error("Failed to load metadata", void 0, {
+        type,
+        name,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  async loadMany(type, options) {
+    const { patterns = ["**/*"], recursive: _recursive = true, limit } = options || {};
+    const typeDir = path.join(this.rootDir, type);
+    const items = [];
+    try {
+      const globPatterns = patterns.map(
+        (pattern) => path.join(typeDir, pattern)
+      );
+      for (const pattern of globPatterns) {
+        const files = await (0, import_glob.glob)(pattern, {
+          ignore: ["**/node_modules/**", "**/*.test.*", "**/*.spec.*"],
+          nodir: true
+        });
+        for (const file of files) {
+          if (limit && items.length >= limit) {
+            break;
+          }
+          try {
+            const content = await fs.readFile(file, "utf-8");
+            const format = this.detectFormat(file);
+            const serializer = this.getSerializer(format);
+            if (serializer) {
+              const data = serializer.deserialize(content);
+              items.push(data);
+            }
+          } catch (error) {
+            this.logger?.warn("Failed to load file", {
+              file,
+              error: error instanceof Error ? error.message : String(error)
+            });
+          }
+        }
+        if (limit && items.length >= limit) {
+          break;
+        }
+      }
+      return items;
+    } catch (error) {
+      this.logger?.error("Failed to load many", void 0, {
+        type,
+        patterns,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  async exists(type, name) {
+    const filePath = await this.findFile(type, name);
+    return filePath !== null;
+  }
+  async stat(type, name) {
+    const filePath = await this.findFile(type, name);
+    if (!filePath) {
+      return null;
+    }
+    try {
+      const stats = await fs.stat(filePath);
+      const content = await fs.readFile(filePath, "utf-8");
+      const etag = this.generateETag(content);
+      const format = this.detectFormat(filePath);
+      return {
+        size: stats.size,
+        modifiedAt: stats.mtime.toISOString(),
+        etag,
+        format,
+        path: filePath
+      };
+    } catch (error) {
+      this.logger?.error("Failed to stat file", void 0, {
+        type,
+        name,
+        filePath,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return null;
+    }
+  }
+  async list(type) {
+    const typeDir = path.join(this.rootDir, type);
+    try {
+      const files = await (0, import_glob.glob)("**/*", {
+        cwd: typeDir,
+        ignore: ["**/node_modules/**", "**/*.test.*", "**/*.spec.*"],
+        nodir: true
+      });
+      return files.map((file) => {
+        const ext = path.extname(file);
+        const basename3 = path.basename(file, ext);
+        return basename3;
+      });
+    } catch (error) {
+      this.logger?.error("Failed to list", void 0, {
+        type,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return [];
+    }
+  }
+  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 {
+      const serializer = this.getSerializer(format);
+      if (!serializer) {
+        throw new Error(`No serializer found for format: ${format}`);
+      }
+      const typeDir = path.join(this.rootDir, type);
+      const fileName = `${name}${serializer.getExtension()}`;
+      const filePath = customPath || path.join(typeDir, fileName);
+      if (!overwrite) {
+        try {
+          await fs.access(filePath);
+          throw new Error(`File already exists: ${filePath}`);
+        } catch (error) {
+          if (error.code !== "ENOENT") {
+            throw error;
+          }
+        }
+      }
+      await fs.mkdir(path.dirname(filePath), { recursive: true });
+      let backupPath;
+      if (backup) {
+        try {
+          await fs.access(filePath);
+          backupPath = `${filePath}.bak`;
+          await fs.copyFile(filePath, backupPath);
+        } catch {
+        }
+      }
+      const content = serializer.serialize(data, {
+        prettify,
+        indent,
+        sortKeys
+      });
+      if (atomic) {
+        const tempPath = `${filePath}.tmp`;
+        await fs.writeFile(tempPath, content, "utf-8");
+        await fs.rename(tempPath, filePath);
+      } else {
+        await fs.writeFile(filePath, content, "utf-8");
+      }
+      return {
+        success: true,
+        path: filePath,
+        // format, // Not in schema
+        size: Buffer.byteLength(content, "utf-8"),
+        backupPath,
+        saveTime: Date.now() - startTime
+      };
+    } catch (error) {
+      this.logger?.error("Failed to save metadata", void 0, {
+        type,
+        name,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  /**
+   * Find file for a given type and name
+   */
+  async findFile(type, name) {
+    const typeDir = path.join(this.rootDir, type);
+    const extensions = [".json", ".yaml", ".yml", ".ts", ".js"];
+    for (const ext of extensions) {
+      const filePath = path.join(typeDir, `${name}${ext}`);
+      try {
+        await fs.access(filePath);
+        return filePath;
+      } catch {
+      }
+    }
+    return null;
+  }
+  /**
+   * Detect format from file extension
+   */
+  detectFormat(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    switch (ext) {
+      case ".json":
+        return "json";
+      case ".yaml":
+      case ".yml":
+        return "yaml";
+      case ".ts":
+        return "typescript";
+      case ".js":
+        return "javascript";
+      default:
+        return "json";
+    }
+  }
+  /**
+   * Get serializer for format
+   */
+  getSerializer(format) {
+    return this.serializers.get(format);
+  }
+  /**
+   * 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 = (0, import_node_crypto.createHash)("sha256").update(content).digest("hex").substring(0, 32);
+    return `"${hash}"`;
+  }
+};
+
+// src/node-metadata-manager.ts
+var NodeMetadataManager = class extends MetadataManager {
+  constructor(config) {
+    super(config);
+    if (!config.loaders || config.loaders.length === 0) {
+      const rootDir = config.rootDir || process.cwd();
+      this.registerLoader(new FilesystemLoader(rootDir, this.serializers, this.logger));
+    }
+    if (config.watch) {
+      this.startWatching();
+    }
+  }
+  /**
+   * Stop all watching
+   */
+  async stopWatching() {
+    if (this.watcher) {
+      await this.watcher.close();
+      this.watcher = void 0;
+    }
+  }
+  /**
+   * 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 = (0, import_chokidar.watch)(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 = path2.relative(rootDir, filePath);
+    const parts = relativePath.split(path2.sep);
+    if (parts.length < 2) {
+      return;
+    }
+    const type = parts[0];
+    const fileName = parts[parts.length - 1];
+    const name = path2.basename(fileName, path2.extname(fileName));
+    let data = void 0;
+    if (eventType !== "deleted") {
+      try {
+        data = await this.load(type, name, { useCache: false });
+      } catch (error) {
+        this.logger.error("Failed to load changed file", void 0, {
+          filePath,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        return;
+      }
+    }
+    const event = {
+      type: eventType,
+      metadataType: type,
+      name,
+      path: filePath,
+      data,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.notifyWatchers(type, event);
+  }
+};
+
+// src/plugin.ts
+var import_kernel = require("@objectstack/spec/kernel");
+var MetadataPlugin = class {
+  constructor(options = {}) {
+    this.name = "com.objectstack.metadata";
+    this.type = "standard";
+    this.version = "1.0.0";
+    this.init = async (ctx) => {
+      ctx.logger.info("Initializing Metadata Manager", {
+        root: this.options.rootDir || process.cwd(),
+        watch: this.options.watch
+      });
+      ctx.registerService("metadata", this.manager);
+      ctx.registerService("app.com.objectstack.metadata", {
+        id: "com.objectstack.metadata",
+        name: "Metadata",
+        version: "1.0.0",
+        type: "plugin",
+        namespace: "sys",
+        objects: [SysMetadataObject]
+      });
+      ctx.logger.info("MetadataPlugin providing metadata service (primary mode)", {
+        mode: "file-system",
+        features: ["watch", "persistence", "multi-format", "query", "overlay", "type-registry"]
+      });
+    };
+    this.start = async (ctx) => {
+      ctx.logger.info("Loading metadata from file system...");
+      const sortedTypes = [...import_kernel.DEFAULT_METADATA_TYPE_REGISTRY].sort((a, b) => a.loadOrder - b.loadOrder);
+      let totalLoaded = 0;
+      for (const entry of sortedTypes) {
+        try {
+          const items = await this.manager.loadMany(entry.type, {
+            recursive: true
+          });
+          if (items.length > 0) {
+            for (const item of items) {
+              const meta = item;
+              if (meta?.name) {
+                await this.manager.register(entry.type, meta.name, item);
+              }
+            }
+            ctx.logger.info(`Loaded ${items.length} ${entry.type} from file system`);
+            totalLoaded += items.length;
+          }
+        } catch (e) {
+          ctx.logger.debug(`No ${entry.type} metadata found`, { error: e.message });
+        }
+      }
+      ctx.logger.info("Metadata loading complete", {
+        totalItems: totalLoaded,
+        registeredTypes: sortedTypes.length
+      });
+    };
+    this.options = {
+      watch: true,
+      ...options
+    };
+    const rootDir = this.options.rootDir || process.cwd();
+    this.manager = new NodeMetadataManager({
+      rootDir,
+      watch: this.options.watch ?? true,
+      formats: ["yaml", "json", "typescript", "javascript"]
+    });
+    this.manager.setTypeRegistry(import_kernel.DEFAULT_METADATA_TYPE_REGISTRY);
+  }
+};
+
+// src/loaders/memory-loader.ts
+var MemoryLoader = class {
+  constructor() {
+    this.contract = {
+      name: "memory",
+      protocol: "memory:",
+      capabilities: {
+        read: true,
+        write: true,
+        watch: false,
+        list: true
+      }
+    };
+    // Storage: Type -> Name -> Data
+    this.storage = /* @__PURE__ */ 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: (/* @__PURE__ */ new Date()).toISOString(),
+        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, /* @__PURE__ */ new Map());
+    }
+    this.storage.get(type).set(name, data);
+    return {
+      success: true,
+      path: `memory://${type}/${name}`,
+      saveTime: 0
+    };
+  }
+};
+
+// src/loaders/remote-loader.ts
+var RemoteLoader = class {
+  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) {
+    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()).toISOString(),
+      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
+    };
+  }
+};
+
+// src/migration/index.ts
+var migration_exports = {};
+__export(migration_exports, {
+  MigrationExecutor: () => MigrationExecutor
+});
+
+// src/migration/executor.ts
+var MigrationExecutor = class {
+  constructor(driver) {
+    this.driver = driver;
+  }
+  async executeChangeSet(changeSet) {
+    console.log(`Executing ChangeSet: ${changeSet.name} (${changeSet.id})`);
+    for (const op of changeSet.operations) {
+      try {
+        await this.executeOperation(op);
+      } catch (e) {
+        console.error(`Failed to execute operation ${op.type}:`, e);
+        throw e;
+      }
+    }
+  }
+  async executeOperation(op) {
+    switch (op.type) {
+      case "create_object":
+        console.log(`  > Create Object: ${op.object.name}`);
+        await this.driver.createCollection(op.object.name, op.object);
+        break;
+      case "add_field":
+        console.log(`  > Add Field: ${op.objectName}.${op.fieldName}`);
+        await this.driver.addColumn(op.objectName, op.fieldName, op.field);
+        break;
+      case "remove_field":
+        console.log(`  > Remove Field: ${op.objectName}.${op.fieldName}`);
+        await this.driver.dropColumn(op.objectName, op.fieldName);
+        break;
+      case "delete_object":
+        console.log(`  > Delete Object: ${op.objectName}`);
+        await this.driver.dropCollection(op.objectName);
+        break;
+      case "execute_sql":
+        console.log(`  > Execute SQL`);
+        await this.driver.executeRaw(op.sql);
+        break;
+      case "modify_field":
+        console.warn(`  ! Modify Field: ${op.objectName}.${op.fieldName} (Not fully implemented)`);
+        break;
+      case "rename_object":
+        console.warn(`  ! Rename Object: ${op.oldName} -> ${op.newName} (Not fully implemented)`);
+        break;
+      default:
+        throw new Error(`Unknown operation type`);
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DatabaseLoader,
+  FilesystemLoader,
+  JSONSerializer,
+  MemoryLoader,
+  MetadataManager,
+  MetadataPlugin,
+  Migration,
+  NodeMetadataManager,
+  RemoteLoader,
+  SysMetadataObject,
+  TypeScriptSerializer,
+  YAMLSerializer
+});
+//# sourceMappingURL=node.cjs.map