@objectstack/objectql 1.0.10 → 1.0.12

package/dist/index.mjs

@@ -1,30 +1,277 @@
 // src/registry.ts
 import { ObjectSchema } from "@objectstack/spec/data";
-import { ManifestSchema } from "@objectstack/spec/kernel";
+import { ManifestSchema, InstalledPackageSchema } from "@objectstack/spec/kernel";
 import { AppSchema } from "@objectstack/spec/ui";
+var RESERVED_NAMESPACES = /* @__PURE__ */ new Set(["base", "system"]);
+var DEFAULT_OWNER_PRIORITY = 100;
+var DEFAULT_EXTENDER_PRIORITY = 200;
+function computeFQN(namespace, shortName) {
+  if (!namespace || RESERVED_NAMESPACES.has(namespace)) {
+    return shortName;
+  }
+  return `${namespace}__${shortName}`;
+}
+function parseFQN(fqn) {
+  const idx = fqn.indexOf("__");
+  if (idx === -1) {
+    return { namespace: void 0, shortName: fqn };
+  }
+  return {
+    namespace: fqn.slice(0, idx),
+    shortName: fqn.slice(idx + 2)
+  };
+}
+function mergeObjectDefinitions(base, extension) {
+  const merged = { ...base };
+  if (extension.fields) {
+    merged.fields = { ...base.fields, ...extension.fields };
+  }
+  if (extension.validations) {
+    merged.validations = [...base.validations || [], ...extension.validations];
+  }
+  if (extension.indexes) {
+    merged.indexes = [...base.indexes || [], ...extension.indexes];
+  }
+  if (extension.label !== void 0) merged.label = extension.label;
+  if (extension.pluralLabel !== void 0) merged.pluralLabel = extension.pluralLabel;
+  if (extension.description !== void 0) merged.description = extension.description;
+  return merged;
+}
 var SchemaRegistry = class {
+  static get logLevel() {
+    return this._logLevel;
+  }
+  static set logLevel(level) {
+    this._logLevel = level;
+  }
+  static log(msg) {
+    if (this._logLevel === "silent" || this._logLevel === "error" || this._logLevel === "warn") return;
+    console.log(msg);
+  }
+  // ==========================================
+  // Namespace Management
+  // ==========================================
+  /**
+   * Register a namespace for a package.
+   * Enforces namespace uniqueness within the instance.
+   * 
+   * @throws Error if namespace is already registered to a different package
+   */
+  static registerNamespace(namespace, packageId) {
+    if (!namespace) return;
+    const existing = this.namespaceRegistry.get(namespace);
+    if (existing && existing !== packageId) {
+      throw new Error(
+        `Namespace "${namespace}" is already registered to package "${existing}". Package "${packageId}" cannot use the same namespace.`
+      );
+    }
+    this.namespaceRegistry.set(namespace, packageId);
+    this.log(`[Registry] Registered namespace: ${namespace} \u2192 ${packageId}`);
+  }
+  /**
+   * Unregister a namespace when a package is uninstalled.
+   */
+  static unregisterNamespace(namespace, packageId) {
+    const existing = this.namespaceRegistry.get(namespace);
+    if (existing === packageId) {
+      this.namespaceRegistry.delete(namespace);
+      this.log(`[Registry] Unregistered namespace: ${namespace}`);
+    }
+  }
+  /**
+   * Get the package that owns a namespace.
+   */
+  static getNamespaceOwner(namespace) {
+    return this.namespaceRegistry.get(namespace);
+  }
+  // ==========================================
+  // Object Registration (Ownership Model)
+  // ==========================================
+  /**
+   * Register an object with ownership semantics.
+   * 
+   * @param schema - The object definition
+   * @param packageId - The owning package ID
+   * @param namespace - The package namespace (for FQN computation)
+   * @param ownership - 'own' (single owner) or 'extend' (additive merge)
+   * @param priority - Merge priority (lower applied first, higher wins on conflict)
+   * 
+   * @throws Error if trying to 'own' an object that already has an owner
+   */
+  static registerObject(schema, packageId, namespace, ownership = "own", priority = ownership === "own" ? DEFAULT_OWNER_PRIORITY : DEFAULT_EXTENDER_PRIORITY) {
+    const shortName = schema.name;
+    const fqn = computeFQN(namespace, shortName);
+    if (namespace) {
+      this.registerNamespace(namespace, packageId);
+    }
+    let contributors = this.objectContributors.get(fqn);
+    if (!contributors) {
+      contributors = [];
+      this.objectContributors.set(fqn, contributors);
+    }
+    if (ownership === "own") {
+      const existingOwner = contributors.find((c) => c.ownership === "own");
+      if (existingOwner && existingOwner.packageId !== packageId) {
+        throw new Error(
+          `Object "${fqn}" is already owned by package "${existingOwner.packageId}". Package "${packageId}" cannot claim ownership. Use 'extend' to add fields.`
+        );
+      }
+      const idx = contributors.findIndex((c) => c.packageId === packageId && c.ownership === "own");
+      if (idx !== -1) {
+        contributors.splice(idx, 1);
+        console.warn(`[Registry] Re-registering owned object: ${fqn} from ${packageId}`);
+      }
+    } else {
+      const idx = contributors.findIndex((c) => c.packageId === packageId && c.ownership === "extend");
+      if (idx !== -1) {
+        contributors.splice(idx, 1);
+      }
+    }
+    const contributor = {
+      packageId,
+      namespace: namespace || "",
+      ownership,
+      priority,
+      definition: { ...schema, name: fqn }
+      // Store with FQN as name
+    };
+    contributors.push(contributor);
+    contributors.sort((a, b) => a.priority - b.priority);
+    this.mergedObjectCache.delete(fqn);
+    this.log(`[Registry] Registered object: ${fqn} (${ownership}, priority=${priority}) from ${packageId}`);
+    return fqn;
+  }
   /**
-   * Universal Register Method
-   * @param type The category of metadata (e.g., 'object', 'app', 'plugin')
-   * @param item The metadata item itself
-   * @param keyField The property to use as the unique key (default: 'name')
+   * Resolve an object by FQN, merging all contributions.
+   * Returns the merged object or undefined if not found.
    */
-  static registerItem(type, item, keyField = "name") {
+  static resolveObject(fqn) {
+    const cached = this.mergedObjectCache.get(fqn);
+    if (cached) return cached;
+    const contributors = this.objectContributors.get(fqn);
+    if (!contributors || contributors.length === 0) {
+      return void 0;
+    }
+    const ownerContrib = contributors.find((c) => c.ownership === "own");
+    if (!ownerContrib) {
+      console.warn(`[Registry] Object "${fqn}" has extenders but no owner. Skipping.`);
+      return void 0;
+    }
+    let merged = { ...ownerContrib.definition };
+    for (const contrib of contributors) {
+      if (contrib.ownership === "extend") {
+        merged = mergeObjectDefinitions(merged, contrib.definition);
+      }
+    }
+    this.mergedObjectCache.set(fqn, merged);
+    return merged;
+  }
+  /**
+   * Get object by name (FQN or short name with fallback scan).
+   * For compatibility, tries exact match first, then scans for suffix match.
+   */
+  static getObject(name) {
+    const direct = this.resolveObject(name);
+    if (direct) return direct;
+    for (const fqn of this.objectContributors.keys()) {
+      const { shortName } = parseFQN(fqn);
+      if (shortName === name) {
+        return this.resolveObject(fqn);
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Get all registered objects (merged).
+   * 
+   * @param packageId - Optional filter: only objects contributed by this package
+   */
+  static getAllObjects(packageId) {
+    const results = [];
+    for (const fqn of this.objectContributors.keys()) {
+      if (packageId) {
+        const contributors = this.objectContributors.get(fqn);
+        const hasContribution = contributors?.some((c) => c.packageId === packageId);
+        if (!hasContribution) continue;
+      }
+      const merged = this.resolveObject(fqn);
+      if (merged) {
+        merged._packageId = this.getObjectOwner(fqn)?.packageId;
+        results.push(merged);
+      }
+    }
+    return results;
+  }
+  /**
+   * Get all contributors for an object.
+   */
+  static getObjectContributors(fqn) {
+    return this.objectContributors.get(fqn) || [];
+  }
+  /**
+   * Get the owner contributor for an object.
+   */
+  static getObjectOwner(fqn) {
+    const contributors = this.objectContributors.get(fqn);
+    return contributors?.find((c) => c.ownership === "own");
+  }
+  /**
+   * Unregister all objects contributed by a package.
+   * 
+   * @throws Error if trying to uninstall an owner that has extenders
+   */
+  static unregisterObjectsByPackage(packageId, force = false) {
+    for (const [fqn, contributors] of this.objectContributors.entries()) {
+      const packageContribs = contributors.filter((c) => c.packageId === packageId);
+      for (const contrib of packageContribs) {
+        if (contrib.ownership === "own" && !force) {
+          const otherExtenders = contributors.filter(
+            (c) => c.packageId !== packageId && c.ownership === "extend"
+          );
+          if (otherExtenders.length > 0) {
+            throw new Error(
+              `Cannot uninstall package "${packageId}": object "${fqn}" is extended by ${otherExtenders.map((c) => c.packageId).join(", ")}. Uninstall extenders first.`
+            );
+          }
+        }
+        const idx = contributors.indexOf(contrib);
+        if (idx !== -1) {
+          contributors.splice(idx, 1);
+          this.log(`[Registry] Removed ${contrib.ownership} contribution to ${fqn} from ${packageId}`);
+        }
+      }
+      if (contributors.length === 0) {
+        this.objectContributors.delete(fqn);
+      }
+      this.mergedObjectCache.delete(fqn);
+    }
+  }
+  // ==========================================
+  // Generic Metadata (Non-Object Types)
+  // ==========================================
+  /**
+   * Universal Register Method for non-object metadata.
+   */
+  static registerItem(type, item, keyField = "name", packageId) {
     if (!this.metadata.has(type)) {
       this.metadata.set(type, /* @__PURE__ */ new Map());
     }
     const collection = this.metadata.get(type);
-    const key = String(item[keyField]);
+    const baseName = String(item[keyField]);
+    if (packageId) {
+      item._packageId = packageId;
+    }
     try {
       this.validate(type, item);
     } catch (e) {
-      console.error(`[Registry] Validation failed for ${type} ${key}: ${e.message}`);
+      console.error(`[Registry] Validation failed for ${type} ${baseName}: ${e.message}`);
     }
-    if (collection.has(key)) {
-      console.warn(`[Registry] Overwriting ${type}: ${key}`);
+    const storageKey = packageId ? `${packageId}:${baseName}` : baseName;
+    if (collection.has(storageKey)) {
+      console.warn(`[Registry] Overwriting ${type}: ${storageKey}`);
     }
-    collection.set(key, item);
-    console.log(`[Registry] Registered ${type}: ${key}`);
+    collection.set(storageKey, item);
+    this.log(`[Registry] Registered ${type}: ${storageKey}`);
   }
   /**
    * Validate Metadata against Spec Zod Schemas
@@ -33,9 +280,12 @@ var SchemaRegistry = class {
     if (type === "object") {
       return ObjectSchema.parse(item);
     }
-    if (type === "app") {
+    if (type === "apps") {
       return AppSchema.parse(item);
     }
+    if (type === "package") {
+      return InstalledPackageSchema.parse(item);
+    }
     if (type === "plugin") {
       return ManifestSchema.parse(item);
     }
@@ -46,66 +296,198 @@ var SchemaRegistry = class {
    */
   static unregisterItem(type, name) {
     const collection = this.metadata.get(type);
-    if (collection && collection.has(name)) {
-      collection.delete(name);
-      console.log(`[Registry] Unregistered ${type}: ${name}`);
-    } else {
+    if (!collection) {
       console.warn(`[Registry] Attempted to unregister non-existent ${type}: ${name}`);
+      return;
+    }
+    if (collection.has(name)) {
+      collection.delete(name);
+      this.log(`[Registry] Unregistered ${type}: ${name}`);
+      return;
     }
+    for (const key of collection.keys()) {
+      if (key.endsWith(`:${name}`)) {
+        collection.delete(key);
+        this.log(`[Registry] Unregistered ${type}: ${key}`);
+        return;
+      }
+    }
+    console.warn(`[Registry] Attempted to unregister non-existent ${type}: ${name}`);
   }
   /**
    * Universal Get Method
    */
   static getItem(type, name) {
-    return this.metadata.get(type)?.get(name);
+    if (type === "object" || type === "objects") {
+      return this.getObject(name);
+    }
+    const collection = this.metadata.get(type);
+    if (!collection) return void 0;
+    const direct = collection.get(name);
+    if (direct) return direct;
+    for (const [key, item] of collection) {
+      if (key.endsWith(`:${name}`)) return item;
+    }
+    return void 0;
   }
   /**
    * Universal List Method
    */
-  static listItems(type) {
-    return Array.from(this.metadata.get(type)?.values() || []);
+  static listItems(type, packageId) {
+    if (type === "object" || type === "objects") {
+      return this.getAllObjects(packageId);
+    }
+    const items = Array.from(this.metadata.get(type)?.values() || []);
+    if (packageId) {
+      return items.filter((item) => item._packageId === packageId);
+    }
+    return items;
   }
   /**
    * Get all registered metadata types (Kinds)
    */
   static getRegisteredTypes() {
-    return Array.from(this.metadata.keys());
+    const types = Array.from(this.metadata.keys());
+    if (!types.includes("object") && this.objectContributors.size > 0) {
+      types.push("object");
+    }
+    return types;
   }
   // ==========================================
-  // Typed Helper Methods (Shortcuts)
+  // Package Management
   // ==========================================
-  /**
-   * Object Helpers
-   */
-  static registerObject(schema) {
-    this.registerItem("object", schema, "name");
+  static installPackage(manifest, settings) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const pkg = {
+      manifest,
+      status: "installed",
+      enabled: true,
+      installedAt: now,
+      updatedAt: now,
+      settings
+    };
+    if (manifest.namespace) {
+      this.registerNamespace(manifest.namespace, manifest.id);
+    }
+    if (!this.metadata.has("package")) {
+      this.metadata.set("package", /* @__PURE__ */ new Map());
+    }
+    const collection = this.metadata.get("package");
+    if (collection.has(manifest.id)) {
+      console.warn(`[Registry] Overwriting package: ${manifest.id}`);
+    }
+    collection.set(manifest.id, pkg);
+    this.log(`[Registry] Installed package: ${manifest.id} (${manifest.name})`);
+    return pkg;
   }
-  static getObject(name) {
-    return this.getItem("object", name);
+  static uninstallPackage(id) {
+    const pkg = this.getPackage(id);
+    if (!pkg) {
+      console.warn(`[Registry] Package not found for uninstall: ${id}`);
+      return false;
+    }
+    if (pkg.manifest.namespace) {
+      this.unregisterNamespace(pkg.manifest.namespace, id);
+    }
+    this.unregisterObjectsByPackage(id);
+    const collection = this.metadata.get("package");
+    if (collection) {
+      collection.delete(id);
+      this.log(`[Registry] Uninstalled package: ${id}`);
+      return true;
+    }
+    return false;
   }
-  static getAllObjects() {
-    return this.listItems("object");
+  static getPackage(id) {
+    return this.metadata.get("package")?.get(id);
   }
-  /**
-   * Plugin Helpers
-   */
+  static getAllPackages() {
+    return this.listItems("package");
+  }
+  static enablePackage(id) {
+    const pkg = this.getPackage(id);
+    if (pkg) {
+      pkg.enabled = true;
+      pkg.status = "installed";
+      pkg.statusChangedAt = (/* @__PURE__ */ new Date()).toISOString();
+      pkg.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.log(`[Registry] Enabled package: ${id}`);
+    }
+    return pkg;
+  }
+  static disablePackage(id) {
+    const pkg = this.getPackage(id);
+    if (pkg) {
+      pkg.enabled = false;
+      pkg.status = "disabled";
+      pkg.statusChangedAt = (/* @__PURE__ */ new Date()).toISOString();
+      pkg.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.log(`[Registry] Disabled package: ${id}`);
+    }
+    return pkg;
+  }
+  // ==========================================
+  // App Helpers
+  // ==========================================
+  static registerApp(app, packageId) {
+    this.registerItem("apps", app, "name", packageId);
+  }
+  static getApp(name) {
+    return this.getItem("apps", name);
+  }
+  static getAllApps() {
+    return this.listItems("apps");
+  }
+  // ==========================================
+  // Plugin Helpers
+  // ==========================================
   static registerPlugin(manifest) {
     this.registerItem("plugin", manifest, "id");
   }
   static getAllPlugins() {
     return this.listItems("plugin");
   }
-  /**
-   * Kind (Metadata Type) Helpers
-   */
+  // ==========================================
+  // Kind Helpers
+  // ==========================================
   static registerKind(kind) {
     this.registerItem("kind", kind, "id");
   }
   static getAllKinds() {
     return this.listItems("kind");
   }
+  // ==========================================
+  // Reset (for testing)
+  // ==========================================
+  /**
+   * Clear all registry state. Use only for testing.
+   */
+  static reset() {
+    this.objectContributors.clear();
+    this.mergedObjectCache.clear();
+    this.namespaceRegistry.clear();
+    this.metadata.clear();
+    this.log("[Registry] Reset complete");
+  }
 };
-// Nested Map: Type -> Name/ID -> MetadataItem
+// ==========================================
+// Logging control
+// ==========================================
+/** Controls verbosity of registry console messages. Default: 'info'. */
+SchemaRegistry._logLevel = "info";
+// ==========================================
+// Object-specific storage (Ownership Model)
+// ==========================================
+/** FQN → Contributor[] (all packages that own/extend this object) */
+SchemaRegistry.objectContributors = /* @__PURE__ */ new Map();
+/** FQN → Merged ServiceObject (cached, invalidated on changes) */
+SchemaRegistry.mergedObjectCache = /* @__PURE__ */ new Map();
+/** Namespace → PackageId (ensures namespace uniqueness) */
+SchemaRegistry.namespaceRegistry = /* @__PURE__ */ new Map();
+// ==========================================
+// Generic metadata storage (non-object types)
+// ==========================================
+/** Type → Name/ID → MetadataItem */
 SchemaRegistry.metadata = /* @__PURE__ */ new Map();
 
 // src/protocol.ts
@@ -149,7 +531,7 @@ var ObjectStackProtocolImplementation = class {
   async getMetaItems(request) {
     return {
       type: request.type,
-      items: SchemaRegistry.listItems(request.type)
+      items: SchemaRegistry.listItems(request.type, request.packageId)
     };
   }
   async getMetaItem(request) {
@@ -162,31 +544,57 @@ var ObjectStackProtocolImplementation = class {
   async getUiView(request) {
     const schema = SchemaRegistry.getObject(request.object);
     if (!schema) throw new Error(`Object ${request.object} not found`);
-    let view;
+    const fields = schema.fields || {};
+    const fieldKeys = Object.keys(fields);
     if (request.type === "list") {
-      view = {
-        type: "list",
-        object: request.object,
-        columns: Object.keys(schema.fields || {}).slice(0, 5).map((f) => ({
-          field: f,
-          label: schema.fields[f].label || f
-        }))
+      const priorityFields = ["name", "title", "label", "subject", "email", "status", "type", "category", "created_at"];
+      let columns = fieldKeys.filter((k) => priorityFields.includes(k));
+      if (columns.length < 5) {
+        const remaining = fieldKeys.filter((k) => !columns.includes(k) && k !== "id" && !fields[k].hidden);
+        columns = [...columns, ...remaining.slice(0, 5 - columns.length)];
+      }
+      return {
+        list: {
+          type: "grid",
+          object: request.object,
+          label: schema.label || schema.name,
+          columns: columns.map((f) => ({
+            field: f,
+            label: fields[f]?.label || f,
+            sortable: true
+          })),
+          sort: fields["created_at"] ? [{ field: "created_at", order: "desc" }] : void 0,
+          searchableFields: columns.slice(0, 3)
+          // Make first few textual columns searchable
+        }
       };
     } else {
-      view = {
-        type: "form",
-        object: request.object,
-        sections: [
-          {
-            label: "General",
-            fields: Object.keys(schema.fields || {}).map((f) => ({
-              field: f
-            }))
-          }
-        ]
+      const formFields = fieldKeys.filter((k) => k !== "id" && k !== "created_at" && k !== "modified_at" && !fields[k].hidden).map((f) => ({
+        field: f,
+        label: fields[f]?.label,
+        required: fields[f]?.required,
+        readonly: fields[f]?.readonly,
+        type: fields[f]?.type,
+        // Default to 2 columns for most, 1 for textareas
+        colSpan: fields[f]?.type === "textarea" || fields[f]?.type === "html" ? 2 : 1
+      }));
+      return {
+        form: {
+          type: "simple",
+          object: request.object,
+          label: `Edit ${schema.label || schema.name}`,
+          sections: [
+            {
+              label: "General Information",
+              columns: 2,
+              collapsible: false,
+              collapsed: false,
+              fields: formFields
+            }
+          ]
+        }
       };
     }
-    return view;
   }
   async findData(request) {
     const options = { ...request.query };
@@ -426,23 +834,98 @@ var ObjectQL = class {
   }
   /**
    * Register contribution (Manifest)
+   * 
+   * Installs the manifest as a Package (the unit of installation),
+   * then decomposes it into individual metadata items (objects, apps, actions, etc.)
+   * and registers each into the SchemaRegistry.
+   * 
+   * Key: Package ≠ App. The manifest is the package. The apps[] array inside
+   * the manifest contains UI navigation definitions (AppSchema).
    */
   registerApp(manifest) {
-    const id = manifest.id;
-    this.logger.debug("Registering app manifest", { id });
+    const id = manifest.id || manifest.name;
+    const namespace = manifest.namespace;
+    this.logger.debug("Registering package manifest", { id, namespace });
+    SchemaRegistry.installPackage(manifest);
+    this.logger.debug("Installed Package", { id: manifest.id, name: manifest.name, namespace });
     if (manifest.objects) {
       if (Array.isArray(manifest.objects)) {
         this.logger.debug("Registering objects from manifest (Array)", { id, objectCount: manifest.objects.length });
         for (const objDef of manifest.objects) {
-          SchemaRegistry.registerObject(objDef);
-          this.logger.debug("Registered Object", { object: objDef.name, from: id });
+          const fqn = SchemaRegistry.registerObject(objDef, id, namespace, "own");
+          this.logger.debug("Registered Object", { fqn, from: id });
         }
       } else {
         this.logger.debug("Registering objects from manifest (Map)", { id, objectCount: Object.keys(manifest.objects).length });
         for (const [name, objDef] of Object.entries(manifest.objects)) {
           objDef.name = name;
-          SchemaRegistry.registerObject(objDef);
-          this.logger.debug("Registered Object", { object: name, from: id });
+          const fqn = SchemaRegistry.registerObject(objDef, id, namespace, "own");
+          this.logger.debug("Registered Object", { fqn, from: id });
+        }
+      }
+    }
+    if (Array.isArray(manifest.objectExtensions) && manifest.objectExtensions.length > 0) {
+      this.logger.debug("Registering object extensions", { id, count: manifest.objectExtensions.length });
+      for (const ext of manifest.objectExtensions) {
+        const targetFqn = ext.extend;
+        const priority = ext.priority ?? 200;
+        const extDef = {
+          name: targetFqn,
+          // Use the target FQN as name
+          fields: ext.fields,
+          label: ext.label,
+          pluralLabel: ext.pluralLabel,
+          description: ext.description,
+          validations: ext.validations,
+          indexes: ext.indexes
+        };
+        SchemaRegistry.registerObject(extDef, id, void 0, "extend", priority);
+        this.logger.debug("Registered Object Extension", { target: targetFqn, priority, from: id });
+      }
+    }
+    if (Array.isArray(manifest.apps) && manifest.apps.length > 0) {
+      this.logger.debug("Registering apps from manifest", { id, count: manifest.apps.length });
+      for (const app of manifest.apps) {
+        const appName = app.name || app.id;
+        if (appName) {
+          SchemaRegistry.registerApp(app, id);
+          this.logger.debug("Registered App", { app: appName, from: id });
+        }
+      }
+    }
+    if (manifest.name && manifest.navigation && !manifest.apps?.length) {
+      SchemaRegistry.registerApp(manifest, id);
+      this.logger.debug("Registered manifest-as-app", { app: manifest.name, from: id });
+    }
+    const metadataArrayKeys = [
+      "actions",
+      "dashboards",
+      "reports",
+      "flows",
+      "agents",
+      "apis",
+      "ragPipelines",
+      "profiles",
+      "sharingRules"
+    ];
+    for (const key of metadataArrayKeys) {
+      const items = manifest[key];
+      if (Array.isArray(items) && items.length > 0) {
+        this.logger.debug(`Registering ${key} from manifest`, { id, count: items.length });
+        for (const item of items) {
+          const itemName = item.name || item.id;
+          if (itemName) {
+            SchemaRegistry.registerItem(key, item, "name", id);
+          }
+        }
+      }
+    }
+    const seedData = manifest.data;
+    if (Array.isArray(seedData) && seedData.length > 0) {
+      this.logger.debug("Registering seed data datasets", { id, count: seedData.length });
+      for (const dataset of seedData) {
+        if (dataset.object) {
+          SchemaRegistry.registerItem("data", dataset, "object", id);
         }
       }
     }
@@ -478,6 +961,23 @@ var ObjectQL = class {
   getSchema(objectName) {
     return SchemaRegistry.getObject(objectName);
   }
+  /**
+   * Resolve an object name to its Fully Qualified Name (FQN).
+   * 
+   * Short names like 'task' are resolved to FQN like 'todo__task'
+   * via SchemaRegistry lookup. If no match is found, the name is
+   * returned as-is (for ad-hoc / unregistered objects).
+   * 
+   * This ensures that all driver operations use a consistent key
+   * regardless of whether the caller uses the short name or FQN.
+   */
+  resolveObjectName(name) {
+    const schema = SchemaRegistry.getObject(name);
+    if (schema) {
+      return schema.name;
+    }
+    return name;
+  }
   /**
    * Helper to get the target driver
    */
@@ -561,6 +1061,7 @@ var ObjectQL = class {
   // Data Access Methods (IDataEngine Interface)
   // ============================================
   async find(object, query) {
+    object = this.resolveObjectName(object);
     this.logger.debug("Find operation starting", { object, query });
     const driver = this.getDriver(object);
     const ast = this.toQueryAST(object, query);
@@ -584,6 +1085,7 @@ var ObjectQL = class {
     }
   }
   async findOne(objectName, query) {
+    objectName = this.resolveObjectName(objectName);
     this.logger.debug("FindOne operation", { objectName });
     const driver = this.getDriver(objectName);
     const ast = this.toQueryAST(objectName, query);
@@ -591,6 +1093,7 @@ var ObjectQL = class {
     return driver.findOne(objectName, ast);
   }
   async insert(object, data, options) {
+    object = this.resolveObjectName(object);
     this.logger.debug("Insert operation starting", { object, isBatch: Array.isArray(data) });
     const driver = this.getDriver(object);
     const hookContext = {
@@ -621,6 +1124,7 @@ var ObjectQL = class {
     }
   }
   async update(object, data, options) {
+    object = this.resolveObjectName(object);
     this.logger.debug("Update operation starting", { object });
     const driver = this.getDriver(object);
     let id = data.id || data._id;
@@ -656,6 +1160,7 @@ var ObjectQL = class {
     }
   }
   async delete(object, options) {
+    object = this.resolveObjectName(object);
     this.logger.debug("Delete operation starting", { object });
     const driver = this.getDriver(object);
     let id = void 0;
@@ -691,6 +1196,7 @@ var ObjectQL = class {
     }
   }
   async count(object, query) {
+    object = this.resolveObjectName(object);
     const driver = this.getDriver(object);
     if (driver.count) {
       const ast = this.toQueryAST(object, { filter: query?.filter });
@@ -700,6 +1206,7 @@ var ObjectQL = class {
     return res.length;
   }
   async aggregate(object, query) {
+    object = this.resolveObjectName(object);
     const driver = this.getDriver(object);
     this.logger.debug(`Aggregate on ${object} using ${driver.name}`, query);
     throw new Error("Aggregate not yet fully implemented in ObjectQL->Driver mapping");
@@ -723,7 +1230,8 @@ var ObjectQLPlugin = class {
     this.version = "1.0.0";
     this.init = async (ctx) => {
       if (!this.ql) {
-        this.ql = new ObjectQL(this.hostContext);
+        const hostCtx = { ...this.hostContext, logger: ctx.logger };
+        this.ql = new ObjectQL(hostCtx);
       }
       ctx.registerService("objectql", this.ql);
       let hasMetadata = false;
@@ -775,9 +1283,14 @@ var ObjectQLPlugin = class {
   }
 };
 export {
+  DEFAULT_EXTENDER_PRIORITY,
+  DEFAULT_OWNER_PRIORITY,
   ObjectQL,
   ObjectQLPlugin,
   ObjectStackProtocolImplementation,
-  SchemaRegistry
+  RESERVED_NAMESPACES,
+  SchemaRegistry,
+  computeFQN,
+  parseFQN
 };
 //# sourceMappingURL=index.mjs.map