@objectstack/metadata 4.0.4 → 4.0.5

package/dist/node.js

@@ -174,277 +174,8 @@ export default metadata;
   }
 };
 
-// src/objects/sys-metadata.object.ts
-import { ObjectSchema, Field } from "@objectstack/spec/data";
-var SysMetadataObject = 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: Field.text({
-      label: "ID",
-      required: true,
-      readonly: true
-    }),
-    /** Machine name — unique identifier used in code references */
-    name: Field.text({
-      label: "Name",
-      required: true,
-      searchable: true,
-      maxLength: 255
-    }),
-    /** Metadata type (e.g. "object", "view", "flow") */
-    type: Field.text({
-      label: "Metadata Type",
-      required: true,
-      searchable: true,
-      maxLength: 100
-    }),
-    /** Namespace / module grouping (e.g. "crm", "core") */
-    namespace: Field.text({
-      label: "Namespace",
-      required: false,
-      defaultValue: "default",
-      maxLength: 100
-    }),
-    /** Package that owns/delivered this metadata */
-    package_id: Field.text({
-      label: "Package ID",
-      required: false,
-      maxLength: 255
-    }),
-    /** Who manages this record: package, platform, or user */
-    managed_by: Field.select(["package", "platform", "user"], {
-      label: "Managed By",
-      required: false
-    }),
-    /** Scope: system (code), platform (admin DB), user (personal DB) */
-    scope: Field.select(["system", "platform", "user"], {
-      label: "Scope",
-      required: true,
-      defaultValue: "platform"
-    }),
-    /** JSON payload — the actual metadata configuration */
-    metadata: Field.textarea({
-      label: "Metadata",
-      required: true,
-      description: "JSON-serialized metadata payload"
-    }),
-    /** Parent metadata name for extension/override */
-    extends: Field.text({
-      label: "Extends",
-      required: false,
-      maxLength: 255
-    }),
-    /** Merge strategy when extending parent metadata */
-    strategy: Field.select(["merge", "replace"], {
-      label: "Strategy",
-      required: false,
-      defaultValue: "merge"
-    }),
-    /** Owner user ID (for user-scope items) */
-    owner: Field.text({
-      label: "Owner",
-      required: false,
-      maxLength: 255
-    }),
-    /** Lifecycle state */
-    state: Field.select(["draft", "active", "archived", "deprecated"], {
-      label: "State",
-      required: false,
-      defaultValue: "active"
-    }),
-    /** Tenant ID for multi-tenant isolation */
-    tenant_id: Field.text({
-      label: "Tenant ID",
-      required: false,
-      maxLength: 255
-    }),
-    /** Version number for optimistic concurrency */
-    version: Field.number({
-      label: "Version",
-      required: false,
-      defaultValue: 1
-    }),
-    /** Content checksum for change detection */
-    checksum: Field.text({
-      label: "Checksum",
-      required: false,
-      maxLength: 64
-    }),
-    /** Origin of this metadata record */
-    source: Field.select(["filesystem", "database", "api", "migration"], {
-      label: "Source",
-      required: false
-    }),
-    /** Classification tags (JSON array) */
-    tags: Field.textarea({
-      label: "Tags",
-      required: false,
-      description: "JSON-serialized array of classification tags"
-    }),
-    /** Audit fields */
-    created_by: Field.text({
-      label: "Created By",
-      required: false,
-      readonly: true,
-      maxLength: 255
-    }),
-    created_at: Field.datetime({
-      label: "Created At",
-      required: false,
-      readonly: true
-    }),
-    updated_by: Field.text({
-      label: "Updated By",
-      required: false,
-      maxLength: 255
-    }),
-    updated_at: 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
-import { ObjectSchema as ObjectSchema2, Field as Field2 } from "@objectstack/spec/data";
-var SysMetadataHistoryObject = ObjectSchema2.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: Field2.text({
-      label: "ID",
-      required: true,
-      readonly: true
-    }),
-    /** Foreign key to sys_metadata.id */
-    metadata_id: Field2.text({
-      label: "Metadata ID",
-      required: true,
-      readonly: true,
-      maxLength: 255
-    }),
-    /** Machine name (denormalized for easier querying) */
-    name: Field2.text({
-      label: "Name",
-      required: true,
-      searchable: true,
-      readonly: true,
-      maxLength: 255
-    }),
-    /** Metadata type (denormalized for easier querying) */
-    type: Field2.text({
-      label: "Metadata Type",
-      required: true,
-      searchable: true,
-      readonly: true,
-      maxLength: 100
-    }),
-    /** Version number at this snapshot */
-    version: Field2.number({
-      label: "Version",
-      required: true,
-      readonly: true
-    }),
-    /** Type of operation that created this history entry */
-    operation_type: Field2.select(["create", "update", "publish", "revert", "delete"], {
-      label: "Operation Type",
-      required: true,
-      readonly: true
-    }),
-    /** Historical metadata snapshot (JSON payload) */
-    metadata: Field2.textarea({
-      label: "Metadata",
-      required: true,
-      readonly: true,
-      description: "JSON-serialized metadata snapshot at this version"
-    }),
-    /** SHA-256 checksum of metadata content */
-    checksum: Field2.text({
-      label: "Checksum",
-      required: true,
-      readonly: true,
-      maxLength: 64
-    }),
-    /** Checksum of the previous version */
-    previous_checksum: Field2.text({
-      label: "Previous Checksum",
-      required: false,
-      readonly: true,
-      maxLength: 64
-    }),
-    /** Human-readable description of changes */
-    change_note: Field2.textarea({
-      label: "Change Note",
-      required: false,
-      readonly: true,
-      description: "Description of what changed in this version"
-    }),
-    /** Tenant ID for multi-tenant isolation */
-    tenant_id: Field2.text({
-      label: "Tenant ID",
-      required: false,
-      readonly: true,
-      maxLength: 255
-    }),
-    /** User who made this change */
-    recorded_by: Field2.text({
-      label: "Recorded By",
-      required: false,
-      readonly: true,
-      maxLength: 255
-    }),
-    /** When was this version recorded */
-    recorded_at: Field2.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
+import { SysMetadataObject, SysMetadataHistoryObject } from "@objectstack/platform-objects/metadata";
 
 // src/utils/metadata-history-utils.ts
 async function calculateChecksum(metadata) {
@@ -544,6 +275,308 @@ function generateDiffSummary(diff) {
   return summary.join(", ");
 }
 
+// src/projection/metadata-projector.ts
+import { StorageNameMapping } from "@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 ? 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) {
@@ -559,11 +592,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.
@@ -572,6 +658,10 @@ var DatabaseLoader = class {
    */
   async ensureSchema() {
     if (this.schemaReady) return;
+    if (this.engine) {
+      this.schemaReady = true;
+      return;
+    }
     try {
       await this.driver.syncSchema(this.tableName, {
         ...SysMetadataObject,
@@ -588,6 +678,10 @@ 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,
@@ -600,16 +694,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;
   }
   /**
@@ -648,10 +744,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,
@@ -664,7 +761,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);
@@ -696,7 +794,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,
@@ -714,8 +813,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) {
@@ -743,8 +841,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);
@@ -755,8 +852,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;
@@ -767,8 +863,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;
@@ -787,8 +882,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"]
       });
@@ -804,8 +898,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;
@@ -813,11 +906,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;
@@ -832,11 +925,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()`
@@ -849,8 +1011,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) {
@@ -858,7 +1019,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,
@@ -884,8 +1045,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) {
@@ -899,7 +1059,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,
@@ -915,6 +1075,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}`,
@@ -923,7 +1086,7 @@ var DatabaseLoader = class {
         };
       } else {
         const id = generateId();
-        await this.driver.create(this.tableName, {
+        await this._create(this.tableName, {
           id,
           name,
           type,
@@ -935,7 +1098,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
         });
@@ -947,6 +1111,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}`,
@@ -965,14 +1132,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() {
@@ -1029,16 +1198,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.
@@ -1952,84 +2160,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
-    });
-    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 dbLoader.queryHistory(type, name, {
+      operationType: options?.operationType,
+      since: options?.since,
+      until: options?.until,
+      limit: options?.limit,
+      offset: options?.offset,
+      includeMetadata: options?.includeMetadata
     });
-    return {
-      records: historyResult,
-      total,
-      hasMore
-    };
   }
   /**
    * Rollback a metadata item to a specific version.
@@ -2099,6 +2237,10 @@ var MetadataManager = class {
   }
 };
 
+// src/plugin.ts
+import { readFile as readFile2 } from "fs/promises";
+import { createHash as createHash2 } from "crypto";
+
 // src/node-metadata-manager.ts
 import * as path2 from "path";
 import { watch as chokidarWatch } from "chokidar";
@@ -2215,7 +2357,7 @@ var FilesystemLoader = class {
       );
       for (const pattern of globPatterns) {
         const files = await glob(pattern, {
-          ignore: ["**/node_modules/**", "**/*.test.*", "**/*.spec.*"],
+          ignore: ["**/node_modules/**", "**/*.test.*", "**/*.spec.*", "**/*[*]*"],
           nodir: true
         });
         for (const file of files) {
@@ -2504,124 +2646,6 @@ var NodeMetadataManager = class extends MetadataManager {
   }
 };
 
-// src/plugin.ts
-import { DEFAULT_METADATA_TYPE_REGISTRY } from "@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 = [...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
-      });
-      let driverBridged = false;
-      try {
-        const ql = ctx.getService("objectql");
-        if (ql) {
-          const tableName = this.manager["config"]?.tableName ?? "sys_metadata";
-          const driver = ql.getDriverForObject?.(tableName);
-          if (driver) {
-            ctx.logger.info("[MetadataPlugin] Bridging driver to MetadataManager via ObjectQL routing", {
-              tableName,
-              driver: driver.name
-            });
-            this.manager.setDatabaseDriver(driver);
-            driverBridged = true;
-          } else {
-            ctx.logger.debug("[MetadataPlugin] ObjectQL could not resolve driver for metadata table", { tableName });
-          }
-        }
-      } catch {
-      }
-      if (!driverBridged) {
-        try {
-          const services = ctx.getServices();
-          for (const [serviceName, service] of services) {
-            if (serviceName.startsWith("driver.") && service) {
-              ctx.logger.info("[MetadataPlugin] Bridging driver to MetadataManager (fallback: first driver)", {
-                driverService: serviceName
-              });
-              this.manager.setDatabaseDriver(service);
-              break;
-            }
-          }
-        } catch (e) {
-          ctx.logger.debug("[MetadataPlugin] No driver service found", { 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(DEFAULT_METADATA_TYPE_REGISTRY);
-  }
-};
-
 // src/loaders/memory-loader.ts
 var MemoryLoader = class {
   constructor() {
@@ -2700,6 +2724,222 @@ var MemoryLoader = class {
   }
 };
 
+// src/plugin.ts
+import { DEFAULT_METADATA_TYPE_REGISTRY } from "@objectstack/spec/kernel";
+import {
+  SysAgent,
+  SysFlow,
+  SysObject,
+  SysTool,
+  SysView
+} from "@objectstack/platform-objects/metadata";
+var queryableMetadataObjects = [SysObject, SysView, SysFlow, SysAgent, 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(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 readFile2(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 = createHash2("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 = [...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) {
@@ -2797,6 +3037,9 @@ var RemoteLoader = class {
   }
 };
 
+// src/index.ts
+import { SysMetadataObject as SysMetadataObject2, SysMetadataHistoryObject as SysMetadataHistoryObject2 } from "@objectstack/platform-objects/metadata";
+
 // src/routes/history-routes.ts
 function registerMetadataHistoryRoutes(app, metadataService) {
   app.get("/api/v1/metadata/:type/:name/history", async (c) => {
@@ -2952,7 +3195,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 {
@@ -2963,8 +3207,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);
@@ -2976,9 +3223,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();
@@ -2988,10 +3238,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,
@@ -3065,20 +3312,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
@@ -3087,7 +3336,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();
@@ -3097,10 +3346,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
@@ -3184,11 +3430,12 @@ export {
   MemoryLoader,
   MetadataManager,
   MetadataPlugin,
+  MetadataProjector,
   migration_exports as Migration,
   NodeMetadataManager,
   RemoteLoader,
-  SysMetadataHistoryObject,
-  SysMetadataObject,
+  SysMetadataHistoryObject2 as SysMetadataHistoryObject,
+  SysMetadataObject2 as SysMetadataObject,
   TypeScriptSerializer,
   YAMLSerializer,
   calculateChecksum,