@objectstack/metadata 4.0.3 → 4.0.5

package/dist/index.cjs

@@ -36,10 +36,11 @@ __export(index_exports, {
   MemoryLoader: () => MemoryLoader,
   MetadataManager: () => MetadataManager,
   MetadataPlugin: () => MetadataPlugin,
+  MetadataProjector: () => MetadataProjector,
   Migration: () => migration_exports,
   RemoteLoader: () => RemoteLoader,
-  SysMetadataHistoryObject: () => SysMetadataHistoryObject,
-  SysMetadataObject: () => SysMetadataObject,
+  SysMetadataHistoryObject: () => import_metadata3.SysMetadataHistoryObject,
+  SysMetadataObject: () => import_metadata3.SysMetadataObject,
   TypeScriptSerializer: () => TypeScriptSerializer,
   YAMLSerializer: () => YAMLSerializer,
   calculateChecksum: () => calculateChecksum,
@@ -219,277 +220,8 @@ export default metadata;
   }
 };
 
-// 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/objects/sys-metadata-history.object.ts
-var import_data2 = require("@objectstack/spec/data");
-var SysMetadataHistoryObject = import_data2.ObjectSchema.create({
-  namespace: "sys",
-  name: "metadata_history",
-  label: "Metadata History",
-  pluralLabel: "Metadata History",
-  icon: "history",
-  isSystem: true,
-  description: "Version history and audit trail for metadata changes",
-  fields: {
-    /** Primary Key (UUID) */
-    id: import_data2.Field.text({
-      label: "ID",
-      required: true,
-      readonly: true
-    }),
-    /** Foreign key to sys_metadata.id */
-    metadata_id: import_data2.Field.text({
-      label: "Metadata ID",
-      required: true,
-      readonly: true,
-      maxLength: 255
-    }),
-    /** Machine name (denormalized for easier querying) */
-    name: import_data2.Field.text({
-      label: "Name",
-      required: true,
-      searchable: true,
-      readonly: true,
-      maxLength: 255
-    }),
-    /** Metadata type (denormalized for easier querying) */
-    type: import_data2.Field.text({
-      label: "Metadata Type",
-      required: true,
-      searchable: true,
-      readonly: true,
-      maxLength: 100
-    }),
-    /** Version number at this snapshot */
-    version: import_data2.Field.number({
-      label: "Version",
-      required: true,
-      readonly: true
-    }),
-    /** Type of operation that created this history entry */
-    operation_type: import_data2.Field.select(["create", "update", "publish", "revert", "delete"], {
-      label: "Operation Type",
-      required: true,
-      readonly: true
-    }),
-    /** Historical metadata snapshot (JSON payload) */
-    metadata: import_data2.Field.textarea({
-      label: "Metadata",
-      required: true,
-      readonly: true,
-      description: "JSON-serialized metadata snapshot at this version"
-    }),
-    /** SHA-256 checksum of metadata content */
-    checksum: import_data2.Field.text({
-      label: "Checksum",
-      required: true,
-      readonly: true,
-      maxLength: 64
-    }),
-    /** Checksum of the previous version */
-    previous_checksum: import_data2.Field.text({
-      label: "Previous Checksum",
-      required: false,
-      readonly: true,
-      maxLength: 64
-    }),
-    /** Human-readable description of changes */
-    change_note: import_data2.Field.textarea({
-      label: "Change Note",
-      required: false,
-      readonly: true,
-      description: "Description of what changed in this version"
-    }),
-    /** Tenant ID for multi-tenant isolation */
-    tenant_id: import_data2.Field.text({
-      label: "Tenant ID",
-      required: false,
-      readonly: true,
-      maxLength: 255
-    }),
-    /** User who made this change */
-    recorded_by: import_data2.Field.text({
-      label: "Recorded By",
-      required: false,
-      readonly: true,
-      maxLength: 255
-    }),
-    /** When was this version recorded */
-    recorded_at: import_data2.Field.datetime({
-      label: "Recorded At",
-      required: true,
-      readonly: true
-    })
-  },
-  indexes: [
-    { fields: ["metadata_id", "version"], unique: true },
-    { fields: ["metadata_id", "recorded_at"] },
-    { fields: ["type", "name"] },
-    { fields: ["recorded_at"] },
-    { fields: ["operation_type"] },
-    { fields: ["tenant_id"] }
-  ],
-  enable: {
-    trackHistory: false,
-    // Don't track history of history records
-    searchable: false,
-    apiEnabled: true,
-    apiMethods: ["get", "list"],
-    // Read-only via API
-    trash: false
-  }
-});
+// src/loaders/database-loader.ts
+var import_metadata = require("@objectstack/platform-objects/metadata");
 
 // src/utils/metadata-history-utils.ts
 async function calculateChecksum(metadata) {
@@ -589,6 +321,308 @@ function generateDiffSummary(diff) {
   return summary.join(", ");
 }
 
+// src/projection/metadata-projector.ts
+var import_system = require("@objectstack/spec/system");
+var MetadataProjector = class {
+  constructor(options) {
+    // Map of metadata types to their target table names
+    this.typeTableMap = {
+      object: "sys_object",
+      view: "sys_view",
+      agent: "sys_agent",
+      tool: "sys_tool",
+      flow: "sys_flow"
+      // Add more as needed: dashboard, app, action, workflow, etc.
+    };
+    if (!options.driver && !options.engine) {
+      throw new Error("MetadataProjector requires either a driver or engine");
+    }
+    this.driver = options.driver;
+    this.engine = options.engine;
+    this.scope = {
+      organizationId: options.organizationId,
+      projectId: options.projectId
+    };
+  }
+  /**
+   * Project metadata to type-specific table
+   */
+  async project(type, name, data) {
+    const targetTable = this.typeTableMap[type];
+    if (!targetTable) {
+      return;
+    }
+    const projectedData = this.transformToProjection(type, name, data);
+    if (!projectedData) {
+      return;
+    }
+    try {
+      const projId = this.scope.projectId ?? null;
+      const existing = await this._findOne(targetTable, {
+        where: { name, project_id: projId }
+      });
+      if (existing) {
+        await this._update(targetTable, existing.id, projectedData);
+      } else {
+        const id = this.generateId();
+        await this._create(targetTable, {
+          id,
+          ...projectedData
+        });
+      }
+    } catch (error) {
+      console.error(`Failed to project ${type}/${name} to ${targetTable}:`, error);
+    }
+  }
+  /**
+   * Delete projection from type-specific table
+   */
+  async deleteProjection(type, name) {
+    const targetTable = this.typeTableMap[type];
+    if (!targetTable) {
+      return;
+    }
+    try {
+      const projId = this.scope.projectId ?? null;
+      const existing = await this._findOne(targetTable, {
+        where: { name, project_id: projId }
+      });
+      if (existing) {
+        await this._delete(targetTable, existing.id);
+      }
+    } catch (error) {
+      console.error(`Failed to delete projection ${type}/${name} from ${targetTable}:`, error);
+    }
+  }
+  /**
+   * Transform metadata into projection record
+   */
+  transformToProjection(type, name, data) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    switch (type) {
+      case "object":
+        return this.projectObject(name, data, now);
+      case "view":
+        return this.projectView(name, data, now);
+      case "agent":
+        return this.projectAgent(name, data, now);
+      case "tool":
+        return this.projectTool(name, data, now);
+      case "flow":
+        return this.projectFlow(name, data, now);
+      default:
+        return null;
+    }
+  }
+  /**
+   * Project object metadata to sys_object
+   */
+  projectObject(name, data, now) {
+    return {
+      name,
+      project_id: this.scope.projectId ?? null,
+      label: data.label || name,
+      plural_label: data.pluralLabel || data.label || name,
+      description: data.description || "",
+      icon: data.icon || "database",
+      namespace: data.namespace || "default",
+      tags: Array.isArray(data.tags) ? data.tags.join(",") : data.tags || "",
+      active: data.active !== false,
+      is_system: data.isSystem || false,
+      abstract: data.abstract || false,
+      datasource: data.datasource || "default",
+      table_name: data.name ? import_system.StorageNameMapping.resolveTableName({ name: data.name }) : name,
+      // Serialize complex structures as JSON
+      fields_json: data.fields ? JSON.stringify(data.fields) : null,
+      indexes_json: data.indexes ? JSON.stringify(data.indexes) : null,
+      validations_json: data.validations ? JSON.stringify(data.validations) : null,
+      state_machines_json: data.stateMachines ? JSON.stringify(data.stateMachines) : null,
+      capabilities_json: data.enable ? JSON.stringify(data.enable) : null,
+      // Denormalized fields
+      field_count: data.fields ? Object.keys(data.fields).length : 0,
+      display_name_field: data.displayNameField || null,
+      title_format: data.titleFormat || null,
+      compact_layout: Array.isArray(data.compactLayout) ? data.compactLayout.join(",") : data.compactLayout || null,
+      // Capabilities (denormalized for easier querying)
+      track_history: data.enable?.trackHistory || false,
+      searchable: data.enable?.searchable !== false,
+      api_enabled: data.enable?.apiEnabled !== false,
+      files: data.enable?.files || false,
+      feeds: data.enable?.feeds || false,
+      activities: data.enable?.activities || false,
+      trash: data.enable?.trash !== false,
+      mru: data.enable?.mru !== false,
+      clone: data.enable?.clone !== false,
+      // Package management
+      package_id: data.packageId || null,
+      managed_by: data.managedBy || "user",
+      // Audit
+      created_by: data.createdBy || null,
+      created_at: data.createdAt || now,
+      updated_by: data.updatedBy || null,
+      updated_at: now
+    };
+  }
+  /**
+   * Project view metadata to sys_view
+   */
+  projectView(name, data, now) {
+    return {
+      name,
+      project_id: this.scope.projectId ?? null,
+      label: data.label || name,
+      description: data.description || "",
+      object_name: data.object || "",
+      view_type: data.type || "grid",
+      // Serialize configurations as JSON
+      columns_json: data.columns ? JSON.stringify(data.columns) : null,
+      filters_json: data.filters ? JSON.stringify(data.filters) : null,
+      sort_json: data.sort ? JSON.stringify(data.sort) : null,
+      config_json: data.config ? JSON.stringify(data.config) : null,
+      // Display options
+      page_size: data.pageSize || 25,
+      show_search: data.showSearch !== false,
+      show_filters: data.showFilters !== false,
+      // Classification
+      namespace: data.namespace || "default",
+      // Package management
+      package_id: data.packageId || null,
+      managed_by: data.managedBy || "user",
+      // Audit
+      created_by: data.createdBy || null,
+      created_at: data.createdAt || now,
+      updated_by: data.updatedBy || null,
+      updated_at: now
+    };
+  }
+  /**
+   * Project agent metadata to sys_agent
+   */
+  projectAgent(name, data, now) {
+    return {
+      name,
+      project_id: this.scope.projectId ?? null,
+      label: data.label || name,
+      description: data.description || "",
+      agent_type: data.type || "conversational",
+      // Model configuration
+      model: data.model || null,
+      temperature: data.temperature ?? 0.7,
+      max_tokens: data.maxTokens || null,
+      top_p: data.topP || null,
+      // System prompt
+      system_prompt: data.systemPrompt || null,
+      // Tools and skills as JSON
+      tools_json: data.tools ? JSON.stringify(data.tools) : null,
+      skills_json: data.skills ? JSON.stringify(data.skills) : null,
+      // Memory
+      memory_enabled: data.memoryEnabled || false,
+      memory_window: data.memoryWindow || 10,
+      // Classification
+      namespace: data.namespace || "default",
+      // Package management
+      package_id: data.packageId || null,
+      managed_by: data.managedBy || "user",
+      // Audit
+      created_by: data.createdBy || null,
+      created_at: data.createdAt || now,
+      updated_by: data.updatedBy || null,
+      updated_at: now
+    };
+  }
+  /**
+   * Project tool metadata to sys_tool
+   */
+  projectTool(name, data, now) {
+    return {
+      name,
+      project_id: this.scope.projectId ?? null,
+      label: data.label || name,
+      description: data.description || "",
+      // Parameters and implementation
+      parameters_json: data.parameters ? JSON.stringify(data.parameters) : null,
+      handler_code: data.handler || null,
+      // Classification
+      namespace: data.namespace || "default",
+      // Package management
+      package_id: data.packageId || null,
+      managed_by: data.managedBy || "user",
+      // Audit
+      created_by: data.createdBy || null,
+      created_at: data.createdAt || now,
+      updated_by: data.updatedBy || null,
+      updated_at: now
+    };
+  }
+  /**
+   * Project flow metadata to sys_flow
+   */
+  projectFlow(name, data, now) {
+    return {
+      name,
+      project_id: this.scope.projectId ?? null,
+      label: data.label || name,
+      description: data.description || "",
+      flow_type: data.type || "autolaunched",
+      // Flow definition
+      nodes_json: data.nodes ? JSON.stringify(data.nodes) : null,
+      edges_json: data.edges ? JSON.stringify(data.edges) : null,
+      variables_json: data.variables ? JSON.stringify(data.variables) : null,
+      // Trigger configuration
+      trigger_type: data.triggerType || null,
+      trigger_object: data.triggerObject || null,
+      // Status
+      active: data.active || false,
+      // Classification
+      namespace: data.namespace || "default",
+      // Package management
+      package_id: data.packageId || null,
+      managed_by: data.managedBy || "user",
+      // Audit
+      created_by: data.createdBy || null,
+      created_at: data.createdAt || now,
+      updated_by: data.updatedBy || null,
+      updated_at: now
+    };
+  }
+  // ==========================================
+  // Internal CRUD helpers (driver vs engine)
+  // ==========================================
+  async _findOne(table, query) {
+    if (this.engine) {
+      return this.engine.findOne(table, query);
+    }
+    return this.driver.findOne(table, { object: table, ...query });
+  }
+  async _create(table, data) {
+    if (this.engine) {
+      return this.engine.insert(table, data);
+    }
+    return this.driver.create(table, data);
+  }
+  async _update(table, id, data) {
+    if (this.engine) {
+      return this.engine.update(table, { id, ...data });
+    }
+    return this.driver.update(table, id, data);
+  }
+  async _delete(table, id) {
+    if (this.engine) {
+      return this.engine.delete(table, { where: { id } });
+    }
+    return this.driver.delete(table, id);
+  }
+  /**
+   * Generate a simple unique ID
+   */
+  generateId() {
+    if (typeof globalThis.crypto !== "undefined" && typeof globalThis.crypto.randomUUID === "function") {
+      return globalThis.crypto.randomUUID();
+    }
+    return `proj_${Date.now()}_${Math.random().toString(36).substring(2, 10)}`;
+  }
+};
+
 // src/loaders/database-loader.ts
 var DatabaseLoader = class {
   constructor(options) {
@@ -604,11 +638,64 @@ var DatabaseLoader = class {
     };
     this.schemaReady = false;
     this.historySchemaReady = false;
+    if (!options.driver && !options.engine) {
+      throw new Error("DatabaseLoader requires either a driver or engine");
+    }
     this.driver = options.driver;
+    this.engine = options.engine;
     this.tableName = options.tableName ?? "sys_metadata";
     this.historyTableName = options.historyTableName ?? "sys_metadata_history";
-    this.tenantId = options.tenantId;
+    this.organizationId = options.organizationId;
+    this.projectId = options.projectId;
     this.trackHistory = options.trackHistory !== false;
+    this.enableProjection = options.enableProjection !== false;
+    if (this.enableProjection) {
+      this.projector = new MetadataProjector({
+        driver: this.driver,
+        engine: this.engine,
+        organizationId: this.organizationId,
+        projectId: this.projectId
+      });
+    }
+  }
+  // ==========================================
+  // Internal CRUD helpers (driver vs engine)
+  // ==========================================
+  async _find(table, query) {
+    if (this.engine) {
+      return this.engine.find(table, query);
+    }
+    return this.driver.find(table, { object: table, ...query });
+  }
+  async _findOne(table, query) {
+    if (this.engine) {
+      return this.engine.findOne(table, query);
+    }
+    return this.driver.findOne(table, { object: table, ...query });
+  }
+  async _count(table, query) {
+    if (this.engine) {
+      return this.engine.count(table, query);
+    }
+    return this.driver.count(table, { object: table, ...query });
+  }
+  async _create(table, data) {
+    if (this.engine) {
+      return this.engine.insert(table, data);
+    }
+    return this.driver.create(table, data);
+  }
+  async _update(table, id, data) {
+    if (this.engine) {
+      return this.engine.update(table, { id, ...data });
+    }
+    return this.driver.update(table, id, data);
+  }
+  async _delete(table, id) {
+    if (this.engine) {
+      return this.engine.delete(table, { where: { id } });
+    }
+    return this.driver.delete(table, id);
   }
   /**
    * Ensure the metadata table exists.
@@ -617,9 +704,13 @@ var DatabaseLoader = class {
    */
   async ensureSchema() {
     if (this.schemaReady) return;
+    if (this.engine) {
+      this.schemaReady = true;
+      return;
+    }
     try {
       await this.driver.syncSchema(this.tableName, {
-        ...SysMetadataObject,
+        ...import_metadata.SysMetadataObject,
         name: this.tableName
       });
       this.schemaReady = true;
@@ -633,9 +724,13 @@ var DatabaseLoader = class {
    */
   async ensureHistorySchema() {
     if (!this.trackHistory || this.historySchemaReady) return;
+    if (this.engine) {
+      this.historySchemaReady = true;
+      return;
+    }
     try {
       await this.driver.syncSchema(this.historyTableName, {
-        ...SysMetadataHistoryObject,
+        ...import_metadata.SysMetadataHistoryObject,
         name: this.historyTableName
       });
       this.historySchemaReady = true;
@@ -645,16 +740,18 @@ var DatabaseLoader = class {
   }
   /**
    * Build base filter conditions for queries.
-   * Always includes tenantId when configured.
+   * Filters by organizationId when configured; project_id when projectId is set,
+   * or null (platform-global) when not set.
    */
   baseFilter(type, name) {
     const filter = { type };
     if (name !== void 0) {
       filter.name = name;
     }
-    if (this.tenantId) {
-      filter.tenant_id = this.tenantId;
+    if (this.organizationId) {
+      filter.organization_id = this.organizationId;
     }
+    filter.project_id = this.projectId ?? null;
     return filter;
   }
   /**
@@ -693,10 +790,11 @@ var DatabaseLoader = class {
       changeNote,
       recordedBy,
       recordedAt: now,
-      ...this.tenantId ? { tenantId: this.tenantId } : {}
+      ...this.organizationId ? { organizationId: this.organizationId } : {},
+      ...this.projectId !== void 0 ? { projectId: this.projectId } : {}
     };
     try {
-      await this.driver.create(this.historyTableName, {
+      await this._create(this.historyTableName, {
         id: historyRecord.id,
         metadata_id: historyRecord.metadataId,
         name: historyRecord.name,
@@ -709,7 +807,8 @@ var DatabaseLoader = class {
         change_note: historyRecord.changeNote,
         recorded_by: historyRecord.recordedBy,
         recorded_at: historyRecord.recordedAt,
-        ...this.tenantId ? { tenant_id: this.tenantId } : {}
+        ...this.organizationId ? { organization_id: this.organizationId } : {},
+        ...this.projectId !== void 0 ? { project_id: this.projectId } : {}
       });
     } catch (error) {
       console.error(`Failed to create history record for ${type}/${name}:`, error);
@@ -741,7 +840,8 @@ var DatabaseLoader = class {
       strategy: row.strategy ?? "merge",
       owner: row.owner,
       state: row.state ?? "active",
-      tenantId: row.tenant_id,
+      organizationId: row.organization_id,
+      projectId: row.project_id,
       version: row.version ?? 1,
       checksum: row.checksum,
       source: row.source,
@@ -759,8 +859,7 @@ var DatabaseLoader = class {
     const startTime = Date.now();
     await this.ensureSchema();
     try {
-      const row = await this.driver.findOne(this.tableName, {
-        object: this.tableName,
+      const row = await this._findOne(this.tableName, {
         where: this.baseFilter(type, name)
       });
       if (!row) {
@@ -788,8 +887,7 @@ var DatabaseLoader = class {
   async loadMany(type, _options) {
     await this.ensureSchema();
     try {
-      const rows = await this.driver.find(this.tableName, {
-        object: this.tableName,
+      const rows = await this._find(this.tableName, {
         where: this.baseFilter(type)
       });
       return rows.map((row) => this.rowToData(row)).filter((data) => data !== null);
@@ -800,8 +898,7 @@ var DatabaseLoader = class {
   async exists(type, name) {
     await this.ensureSchema();
     try {
-      const count = await this.driver.count(this.tableName, {
-        object: this.tableName,
+      const count = await this._count(this.tableName, {
         where: this.baseFilter(type, name)
       });
       return count > 0;
@@ -812,8 +909,7 @@ var DatabaseLoader = class {
   async stat(type, name) {
     await this.ensureSchema();
     try {
-      const row = await this.driver.findOne(this.tableName, {
-        object: this.tableName,
+      const row = await this._findOne(this.tableName, {
         where: this.baseFilter(type, name)
       });
       if (!row) return null;
@@ -832,8 +928,7 @@ var DatabaseLoader = class {
   async list(type) {
     await this.ensureSchema();
     try {
-      const rows = await this.driver.find(this.tableName, {
-        object: this.tableName,
+      const rows = await this._find(this.tableName, {
         where: this.baseFilter(type),
         fields: ["name"]
       });
@@ -849,8 +944,7 @@ var DatabaseLoader = class {
   async getHistoryRecord(type, name, version) {
     if (!this.trackHistory) return null;
     await this.ensureHistorySchema();
-    const metadataRow = await this.driver.findOne(this.tableName, {
-      object: this.tableName,
+    const metadataRow = await this._findOne(this.tableName, {
       where: this.baseFilter(type, name)
     });
     if (!metadataRow) return null;
@@ -858,11 +952,11 @@ var DatabaseLoader = class {
       metadata_id: metadataRow.id,
       version
     };
-    if (this.tenantId) {
-      filter.tenant_id = this.tenantId;
+    if (this.organizationId) {
+      filter.organization_id = this.organizationId;
     }
-    const row = await this.driver.findOne(this.historyTableName, {
-      object: this.historyTableName,
+    filter.project_id = this.projectId ?? null;
+    const row = await this._findOne(this.historyTableName, {
       where: filter
     });
     if (!row) return null;
@@ -877,11 +971,80 @@ var DatabaseLoader = class {
       checksum: row.checksum,
       previousChecksum: row.previous_checksum,
       changeNote: row.change_note,
-      tenantId: row.tenant_id,
+      organizationId: row.organization_id,
+      projectId: row.project_id,
       recordedBy: row.recorded_by,
       recordedAt: row.recorded_at
     };
   }
+  /**
+   * Query history records with pagination and filtering.
+   * Encapsulates history table queries so MetadataManager doesn't need
+   * direct driver access.
+   */
+  async queryHistory(type, name, options) {
+    if (!this.trackHistory) {
+      return { records: [], total: 0, hasMore: false };
+    }
+    await this.ensureSchema();
+    await this.ensureHistorySchema();
+    const filter = { type, name };
+    if (this.organizationId) filter.organization_id = this.organizationId;
+    filter.project_id = this.projectId ?? null;
+    const metadataRecord = await this._findOne(this.tableName, { where: filter });
+    if (!metadataRecord) {
+      return { records: [], total: 0, hasMore: false };
+    }
+    const historyFilter = {
+      metadata_id: metadataRecord.id
+    };
+    if (this.organizationId) historyFilter.organization_id = this.organizationId;
+    historyFilter.project_id = this.projectId ?? null;
+    if (options?.operationType) historyFilter.operation_type = options.operationType;
+    if (options?.since) historyFilter.recorded_at = { $gte: options.since };
+    if (options?.until) {
+      if (historyFilter.recorded_at) {
+        historyFilter.recorded_at.$lte = options.until;
+      } else {
+        historyFilter.recorded_at = { $lte: options.until };
+      }
+    }
+    const limit = options?.limit ?? 50;
+    const offset = options?.offset ?? 0;
+    const historyRecords = await this._find(this.historyTableName, {
+      where: historyFilter,
+      orderBy: [
+        { field: "recorded_at", order: "desc" },
+        { field: "version", order: "desc" }
+      ],
+      limit: limit + 1,
+      offset
+    });
+    const hasMore = historyRecords.length > limit;
+    const records = historyRecords.slice(0, limit);
+    const total = await this._count(this.historyTableName, { where: historyFilter });
+    const includeMetadata = options?.includeMetadata !== false;
+    const result = records.map((row) => {
+      const parsedMetadata = typeof row.metadata === "string" ? JSON.parse(row.metadata) : row.metadata;
+      return {
+        id: row.id,
+        metadataId: row.metadata_id,
+        name: row.name,
+        type: row.type,
+        version: row.version,
+        operationType: row.operation_type,
+        metadata: includeMetadata ? parsedMetadata : null,
+        checksum: row.checksum,
+        previousChecksum: row.previous_checksum,
+        changeNote: row.change_note,
+        organizationId: row.organization_id,
+        projectId: row.project_id,
+        recordedBy: row.recorded_by,
+        recordedAt: row.recorded_at
+      };
+    });
+    return { records: result, total, hasMore };
+  }
   /**
    * Perform a rollback: persist `restoredData` as the new current state and record a
    * single 'revert' history entry (instead of the usual 'update' entry that `save()`
@@ -894,8 +1057,7 @@ var DatabaseLoader = class {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const metadataJson = JSON.stringify(restoredData);
     const newChecksum = await calculateChecksum(restoredData);
-    const existing = await this.driver.findOne(this.tableName, {
-      object: this.tableName,
+    const existing = await this._findOne(this.tableName, {
       where: this.baseFilter(type, name)
     });
     if (!existing) {
@@ -903,7 +1065,7 @@ var DatabaseLoader = class {
     }
     const previousChecksum = existing.checksum;
     const newVersion = (existing.version ?? 0) + 1;
-    await this.driver.update(this.tableName, existing.id, {
+    await this._update(this.tableName, existing.id, {
       metadata: metadataJson,
       version: newVersion,
       checksum: newChecksum,
@@ -929,8 +1091,7 @@ var DatabaseLoader = class {
     const metadataJson = JSON.stringify(data);
     const newChecksum = await calculateChecksum(data);
     try {
-      const existing = await this.driver.findOne(this.tableName, {
-        object: this.tableName,
+      const existing = await this._findOne(this.tableName, {
         where: this.baseFilter(type, name)
       });
       if (existing) {
@@ -944,7 +1105,7 @@ var DatabaseLoader = class {
           };
         }
         const version = (existing.version ?? 0) + 1;
-        await this.driver.update(this.tableName, existing.id, {
+        await this._update(this.tableName, existing.id, {
           metadata: metadataJson,
           version,
           checksum: newChecksum,
@@ -960,6 +1121,9 @@ var DatabaseLoader = class {
           "update",
           previousChecksum
         );
+        if (this.projector) {
+          await this.projector.project(type, name, data);
+        }
         return {
           success: true,
           path: `datasource://${this.tableName}/${type}/${name}`,
@@ -968,7 +1132,7 @@ var DatabaseLoader = class {
         };
       } else {
         const id = generateId();
-        await this.driver.create(this.tableName, {
+        await this._create(this.tableName, {
           id,
           name,
           type,
@@ -980,7 +1144,8 @@ var DatabaseLoader = class {
           state: "active",
           version: 1,
           source: "database",
-          ...this.tenantId ? { tenant_id: this.tenantId } : {},
+          ...this.organizationId ? { organization_id: this.organizationId } : {},
+          ...this.projectId !== void 0 ? { project_id: this.projectId } : { project_id: null },
           created_at: now,
           updated_at: now
         });
@@ -992,6 +1157,9 @@ var DatabaseLoader = class {
           data,
           "create"
         );
+        if (this.projector) {
+          await this.projector.project(type, name, data);
+        }
         return {
           success: true,
           path: `datasource://${this.tableName}/${type}/${name}`,
@@ -1010,14 +1178,16 @@ var DatabaseLoader = class {
    */
   async delete(type, name) {
     await this.ensureSchema();
-    const existing = await this.driver.findOne(this.tableName, {
-      object: this.tableName,
+    const existing = await this._findOne(this.tableName, {
       where: this.baseFilter(type, name)
     });
     if (!existing) {
       return;
     }
-    await this.driver.delete(this.tableName, existing.id);
+    await this._delete(this.tableName, existing.id);
+    if (this.projector) {
+      await this.projector.deleteProjection(type, name);
+    }
   }
 };
 function generateId() {
@@ -1074,16 +1244,55 @@ var MetadataManager = class {
    * 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) {
+   * @param organizationId - Organization ID for multi-tenant isolation
+   * @param projectId - Project ID (undefined = platform-global)
+   */
+  setDatabaseDriver(driver, organizationId, projectId) {
+    if (projectId !== void 0) {
+      this.logger.info("Project kernel \u2014 skipping DatabaseLoader for sys_metadata (control-plane only)", {
+        organizationId,
+        projectId
+      });
+      return;
+    }
     const tableName = this.config.tableName ?? "sys_metadata";
     const dbLoader = new DatabaseLoader({
       driver,
-      tableName
+      tableName,
+      organizationId,
+      projectId
     });
     this.registerLoader(dbLoader);
     this.logger.info("DatabaseLoader configured", { datasource: this.config.datasource, tableName });
   }
+  /**
+   * Configure and register a DatabaseLoader backed by an IDataEngine (ObjectQL).
+   * The engine handles datasource routing automatically — sys_metadata will
+   * be routed to the correct driver via the standard namespace mapping.
+   * No manual driver resolution needed.
+   *
+   * @param engine - An IDataEngine instance (typically the ObjectQL service)
+   * @param organizationId - Organization ID for multi-tenant isolation
+   * @param projectId - Project ID (undefined = platform-global)
+   */
+  setDataEngine(engine, organizationId, projectId) {
+    if (projectId !== void 0) {
+      this.logger.info("Project kernel \u2014 skipping DatabaseLoader for sys_metadata (control-plane only)", {
+        organizationId,
+        projectId
+      });
+      return;
+    }
+    const tableName = this.config.tableName ?? "sys_metadata";
+    const dbLoader = new DatabaseLoader({
+      engine,
+      tableName,
+      organizationId,
+      projectId
+    });
+    this.registerLoader(dbLoader);
+    this.logger.info("DatabaseLoader configured via DataEngine", { tableName });
+  }
   /**
    * Set the realtime service for publishing metadata change events.
    * Should be called after kernel resolves the realtime service.
@@ -1997,84 +2206,14 @@ var MetadataManager = class {
     if (!dbLoader) {
       throw new Error("History tracking requires a database loader to be configured");
     }
-    const driver = dbLoader.driver;
-    const tableName = dbLoader.tableName;
-    const historyTableName = dbLoader.historyTableName;
-    const tenantId = dbLoader.tenantId;
-    const filter = { type, name };
-    if (tenantId) {
-      filter.tenant_id = tenantId;
-    }
-    const metadataRecord = await driver.findOne(tableName, {
-      object: tableName,
-      where: filter
-    });
-    if (!metadataRecord) {
-      return {
-        records: [],
-        total: 0,
-        hasMore: false
-      };
-    }
-    const historyFilter = {
-      metadata_id: metadataRecord.id
-    };
-    if (tenantId) {
-      historyFilter.tenant_id = tenantId;
-    }
-    if (options?.operationType) {
-      historyFilter.operation_type = options.operationType;
-    }
-    if (options?.since) {
-      historyFilter.recorded_at = { $gte: options.since };
-    }
-    if (options?.until) {
-      if (historyFilter.recorded_at) {
-        historyFilter.recorded_at.$lte = options.until;
-      } else {
-        historyFilter.recorded_at = { $lte: options.until };
-      }
-    }
-    const limit = options?.limit ?? 50;
-    const offset = options?.offset ?? 0;
-    const historyRecords = await driver.find(historyTableName, {
-      object: historyTableName,
-      where: historyFilter,
-      orderBy: [{ field: "recorded_at", order: "desc" }],
-      limit: limit + 1,
-      // Fetch one extra to determine hasMore
-      offset
-    });
-    const hasMore = historyRecords.length > limit;
-    const records = historyRecords.slice(0, limit);
-    const total = await driver.count(historyTableName, {
-      object: historyTableName,
-      where: historyFilter
+    return dbLoader.queryHistory(type, name, {
+      operationType: options?.operationType,
+      since: options?.since,
+      until: options?.until,
+      limit: options?.limit,
+      offset: options?.offset,
+      includeMetadata: options?.includeMetadata
     });
-    const includeMetadata = options?.includeMetadata !== false;
-    const historyResult = records.map((row) => {
-      const parsedMetadata = typeof row.metadata === "string" ? JSON.parse(row.metadata) : row.metadata;
-      return {
-        id: row.id,
-        metadataId: row.metadata_id,
-        name: row.name,
-        type: row.type,
-        version: row.version,
-        operationType: row.operation_type,
-        metadata: includeMetadata ? parsedMetadata : null,
-        checksum: row.checksum,
-        previousChecksum: row.previous_checksum,
-        changeNote: row.change_note,
-        tenantId: row.tenant_id,
-        recordedBy: row.recorded_by,
-        recordedAt: row.recorded_at
-      };
-    });
-    return {
-      records: historyResult,
-      total,
-      hasMore
-    };
   }
   /**
    * Rollback a metadata item to a specific version.
@@ -2144,6 +2283,10 @@ var MetadataManager = class {
   }
 };
 
+// src/plugin.ts
+var import_promises = require("fs/promises");
+var import_node_crypto2 = require("crypto");
+
 // src/node-metadata-manager.ts
 var path2 = __toESM(require("path"), 1);
 var import_chokidar = require("chokidar");
@@ -2260,7 +2403,7 @@ var FilesystemLoader = class {
       );
       for (const pattern of globPatterns) {
         const files = await (0, import_glob.glob)(pattern, {
-          ignore: ["**/node_modules/**", "**/*.test.*", "**/*.spec.*"],
+          ignore: ["**/node_modules/**", "**/*.test.*", "**/*.spec.*", "**/*[*]*"],
           nodir: true
         });
         for (const file of files) {
@@ -2549,105 +2692,6 @@ var NodeMetadataManager = class extends MetadataManager {
   }
 };
 
-// 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);
-      console.log("[MetadataPlugin] Registered metadata service, has getRegisteredTypes:", typeof this.manager.getRegisteredTypes);
-      try {
-        ctx.getService("manifest").register({
-          id: "com.objectstack.metadata",
-          name: "Metadata",
-          version: "1.0.0",
-          type: "plugin",
-          namespace: "sys",
-          objects: [SysMetadataObject]
-        });
-      } catch {
-      }
-      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
-      });
-      try {
-        const services = ctx.getServices();
-        for (const [serviceName, service] of services) {
-          if (serviceName.startsWith("driver.") && service) {
-            ctx.logger.info("[MetadataPlugin] Bridging driver to MetadataManager for database-backed persistence", {
-              driverService: serviceName
-            });
-            this.manager.setDatabaseDriver(service);
-            break;
-          }
-        }
-      } catch (e) {
-        ctx.logger.debug("[MetadataPlugin] No driver service found \u2014 database metadata persistence not available", {
-          error: e.message
-        });
-      }
-      try {
-        const realtimeService = ctx.getService("realtime");
-        if (realtimeService && typeof realtimeService === "object" && "publish" in realtimeService) {
-          ctx.logger.info("[MetadataPlugin] Bridging realtime service to MetadataManager for event publishing");
-          this.manager.setRealtimeService(realtimeService);
-        }
-      } catch (e) {
-        ctx.logger.debug("[MetadataPlugin] No realtime service found \u2014 metadata events will not be published", {
-          error: e.message
-        });
-      }
-    };
-    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() {
@@ -2726,6 +2770,216 @@ var MemoryLoader = class {
   }
 };
 
+// src/plugin.ts
+var import_kernel = require("@objectstack/spec/kernel");
+var import_metadata2 = require("@objectstack/platform-objects/metadata");
+var queryableMetadataObjects = [import_metadata2.SysObject, import_metadata2.SysView, import_metadata2.SysFlow, import_metadata2.SysAgent, import_metadata2.SysTool];
+var ARTIFACT_FIELD_TO_TYPE = {
+  objects: "object",
+  objectExtensions: "object_extension",
+  apps: "app",
+  views: "view",
+  pages: "page",
+  dashboards: "dashboard",
+  reports: "report",
+  actions: "action",
+  themes: "theme",
+  workflows: "workflow",
+  approvals: "approval",
+  flows: "flow",
+  roles: "role",
+  permissions: "permission",
+  sharingRules: "sharing_rule",
+  policies: "policy",
+  apis: "api",
+  webhooks: "webhook",
+  agents: "agent",
+  skills: "skill",
+  ragPipelines: "rag_pipeline",
+  hooks: "hook",
+  mappings: "mapping",
+  analyticsCubes: "analytics_cube",
+  connectors: "connector",
+  data: "dataset"
+};
+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,
+        artifactSource: this.options.artifactSource?.mode
+      });
+      ctx.registerService("metadata", this.manager);
+      console.log("[MetadataPlugin] Registered metadata service, has getRegisteredTypes:", typeof this.manager.getRegisteredTypes);
+      const registerSysObjects = this.options.registerSystemObjects !== false;
+      if (registerSysObjects) {
+        try {
+          const manifestService = ctx.getService("manifest");
+          manifestService.register({
+            id: "com.objectstack.metadata-objects",
+            name: "Metadata Platform Objects",
+            version: "1.0.0",
+            type: "plugin",
+            scope: "system",
+            defaultDatasource: "cloud",
+            objects: queryableMetadataObjects
+          });
+          ctx.logger.info("Registered system metadata objects", {
+            queryable: queryableMetadataObjects.map((object) => object.name)
+          });
+        } catch {
+        }
+      }
+      ctx.logger.info("MetadataPlugin providing metadata service (primary mode)", {
+        mode: this.options.artifactSource?.mode ?? "file-system",
+        features: ["watch", "multi-format", "query", "overlay", "type-registry"]
+      });
+    };
+    this.start = async (ctx) => {
+      const src = this.options.artifactSource;
+      if (src?.mode === "local-file") {
+        await this._loadFromLocalFile(ctx, src.path);
+      } else if (src?.mode === "artifact-api") {
+        ctx.logger.warn("[MetadataPlugin] artifact-api source is not yet implemented; falling back to file-system scan");
+        await this._loadFromFileSystem(ctx);
+      } else {
+        await this._loadFromFileSystem(ctx);
+      }
+      try {
+        const realtimeService = ctx.getService("realtime");
+        if (realtimeService && typeof realtimeService === "object" && "publish" in realtimeService) {
+          ctx.logger.info("[MetadataPlugin] Bridging realtime service to MetadataManager for event publishing");
+          this.manager.setRealtimeService(realtimeService);
+        }
+      } catch (e) {
+        ctx.logger.debug("[MetadataPlugin] No realtime service found \u2014 metadata events will not be published", {
+          error: e.message
+        });
+      }
+    };
+    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);
+  }
+  async _loadFromLocalFile(ctx, filePath) {
+    const isUrl = /^https?:\/\//i.test(filePath);
+    ctx.logger.info(
+      `[MetadataPlugin] Loading metadata from ${isUrl ? "remote URL" : "local artifact file"}`,
+      { path: filePath }
+    );
+    let raw;
+    try {
+      let content;
+      if (isUrl) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 15e3);
+        try {
+          const res = await fetch(filePath, {
+            redirect: "follow",
+            signal: controller.signal,
+            headers: { Accept: "application/json, */*;q=0.5" }
+          });
+          if (!res.ok) {
+            throw new Error(`HTTP ${res.status} ${res.statusText}`);
+          }
+          content = await res.text();
+        } finally {
+          clearTimeout(timer);
+        }
+      } else {
+        content = await (0, import_promises.readFile)(filePath, "utf8");
+      }
+      raw = JSON.parse(content);
+    } catch (e) {
+      throw new Error(`[MetadataPlugin] Cannot read artifact ${isUrl ? "URL" : "file"} at "${filePath}": ${e.message}`);
+    }
+    const { ProjectArtifactSchema } = await import("@objectstack/spec/cloud");
+    const { ObjectStackDefinitionSchema } = await import("@objectstack/spec");
+    let metadata;
+    const obj = raw;
+    if (obj?.schemaVersion && obj?.commitId && obj?.metadata !== void 0) {
+      const artifact = ProjectArtifactSchema.parse(obj);
+      metadata = artifact.metadata;
+    } else {
+      const def = ObjectStackDefinitionSchema.parse(obj);
+      const canonical = JSON.stringify(def, Object.keys(def).sort());
+      const checksum = (0, import_node_crypto2.createHash)("sha256").update(canonical).digest("hex");
+      const projectId = this.options.projectId ?? "proj_local";
+      ProjectArtifactSchema.parse({
+        schemaVersion: "0.1",
+        projectId,
+        commitId: "local-dev",
+        checksum,
+        metadata: def
+      });
+      metadata = def;
+    }
+    const memLoader = new MemoryLoader();
+    const manifestPackageId = metadata?.manifest?.id ?? metadata?.id ?? void 0;
+    let totalRegistered = 0;
+    for (const [field, metaType] of Object.entries(ARTIFACT_FIELD_TO_TYPE)) {
+      const items = metadata[field];
+      if (!Array.isArray(items) || items.length === 0) continue;
+      for (const item of items) {
+        const name = item?.name;
+        if (!name) continue;
+        if (manifestPackageId && item._packageId === void 0) {
+          item._packageId = manifestPackageId;
+        }
+        await memLoader.save(metaType, name, item);
+        await this.manager.register(metaType, name, item);
+        totalRegistered++;
+      }
+    }
+    this.manager.registerLoader(memLoader);
+    ctx.logger.info("[MetadataPlugin] Artifact metadata loaded", {
+      path: filePath,
+      totalRegistered
+    });
+  }
+  async _loadFromFileSystem(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,
+          patterns: entry.filePatterns
+        });
+        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
+    });
+  }
+};
+
 // src/loaders/remote-loader.ts
 var RemoteLoader = class {
   constructor(baseUrl, authToken) {
@@ -2823,6 +3077,9 @@ var RemoteLoader = class {
   }
 };
 
+// src/index.ts
+var import_metadata3 = require("@objectstack/platform-objects/metadata");
+
 // src/routes/history-routes.ts
 function registerMetadataHistoryRoutes(app, metadataService) {
   app.get("/api/v1/metadata/:type/:name/history", async (c) => {
@@ -2978,7 +3235,8 @@ var HistoryCleanupManager = class {
   async runCleanup() {
     const driver = this.dbLoader.driver;
     const historyTableName = this.dbLoader.historyTableName;
-    const tenantId = this.dbLoader.tenantId;
+    const organizationId = this.dbLoader.organizationId;
+    const projectId = this.dbLoader.projectId;
     let deleted = 0;
     let errors = 0;
     try {
@@ -2989,8 +3247,11 @@ var HistoryCleanupManager = class {
         const filter = {
           recorded_at: { $lt: cutoffISO }
         };
-        if (tenantId) {
-          filter.tenant_id = tenantId;
+        if (organizationId) {
+          filter.organization_id = organizationId;
+        }
+        if (projectId !== void 0) {
+          filter.project_id = projectId;
         }
         try {
           const result = await this.bulkDeleteByFilter(driver, historyTableName, filter);
@@ -3002,9 +3263,12 @@ var HistoryCleanupManager = class {
       }
       if (this.policy.maxVersions) {
         try {
+          const baseWhere = {};
+          if (organizationId) baseWhere.organization_id = organizationId;
+          if (projectId !== void 0) baseWhere.project_id = projectId;
           const metadataIds = await driver.find(historyTableName, {
             object: historyTableName,
-            where: tenantId ? { tenant_id: tenantId } : {},
+            where: baseWhere,
             fields: ["metadata_id"]
           });
           const uniqueIds = /* @__PURE__ */ new Set();
@@ -3014,10 +3278,7 @@ var HistoryCleanupManager = class {
             }
           }
           for (const metadataId of uniqueIds) {
-            const filter = { metadata_id: metadataId };
-            if (tenantId) {
-              filter.tenant_id = tenantId;
-            }
+            const filter = { metadata_id: metadataId, ...baseWhere };
             try {
               const historyRecords = await driver.find(historyTableName, {
                 object: historyTableName,
@@ -3091,20 +3352,22 @@ var HistoryCleanupManager = class {
   async getCleanupStats() {
     const driver = this.dbLoader.driver;
     const historyTableName = this.dbLoader.historyTableName;
-    const tenantId = this.dbLoader.tenantId;
+    const organizationId = this.dbLoader.organizationId;
+    const projectId = this.dbLoader.projectId;
     let recordsByAge = 0;
     let recordsByCount = 0;
     try {
+      const baseWhere = {};
+      if (organizationId) baseWhere.organization_id = organizationId;
+      if (projectId !== void 0) baseWhere.project_id = projectId;
       if (this.policy.maxAgeDays) {
         const cutoffDate = /* @__PURE__ */ new Date();
         cutoffDate.setDate(cutoffDate.getDate() - this.policy.maxAgeDays);
         const cutoffISO = cutoffDate.toISOString();
         const filter = {
-          recorded_at: { $lt: cutoffISO }
+          recorded_at: { $lt: cutoffISO },
+          ...baseWhere
         };
-        if (tenantId) {
-          filter.tenant_id = tenantId;
-        }
         recordsByAge = await driver.count(historyTableName, {
           object: historyTableName,
           where: filter
@@ -3113,7 +3376,7 @@ var HistoryCleanupManager = class {
       if (this.policy.maxVersions) {
         const metadataIds = await driver.find(historyTableName, {
           object: historyTableName,
-          where: tenantId ? { tenant_id: tenantId } : {},
+          where: baseWhere,
           fields: ["metadata_id"]
         });
         const uniqueIds = /* @__PURE__ */ new Set();
@@ -3123,10 +3386,7 @@ var HistoryCleanupManager = class {
           }
         }
         for (const metadataId of uniqueIds) {
-          const filter = { metadata_id: metadataId };
-          if (tenantId) {
-            filter.tenant_id = tenantId;
-          }
+          const filter = { metadata_id: metadataId, ...baseWhere };
           const count = await driver.count(historyTableName, {
             object: historyTableName,
             where: filter
@@ -3210,6 +3470,7 @@ var MigrationExecutor = class {
   MemoryLoader,
   MetadataManager,
   MetadataPlugin,
+  MetadataProjector,
   Migration,
   RemoteLoader,
   SysMetadataHistoryObject,