@x12i/memorix-retrieval 1.8.2 → 1.9.2

package/dist/explorer/unified-inventory.js

@@ -1,14 +1,30 @@
 import { parseMemorixCollectionName } from "../data/collection-parser.js";
 import { resolveMemorixCollectionName } from "../data/collection-name.js";
+import { resolveMemorixRecordIdentity } from "../data/record-identity.js";
+import { serializeMemorixDocumentForJson } from "../data/record-id.js";
+import { memorixReadByTarget } from "../data/target-read.js";
 import { DEFAULT_MEMORIX_XRONOX_ROLES, } from "../data/memorix-read.js";
 import { discoverMemorixEntities, loadMemorixEntityDescriptorByName, } from "../descriptors/discover-entities.js";
 import { listEntityContentTypeKeys } from "../descriptors/content-type-labels.js";
-import { MEMORIX_LIST_DESCRIPTORS_CATALOG } from "../descriptors/catalog-ids.js";
+import { MEMORIX_ENTITY_DESCRIPTORS_CATALOG, MEMORIX_ITEM_DESCRIPTORS_CATALOG, MEMORIX_LIST_DESCRIPTORS_CATALOG, } from "../descriptors/catalog-ids.js";
 import { throwRetrievalError } from "../errors/errors.js";
 import { ALL_MEMORIX_TARGETS, resolveMemorixDatabaseName, resolveMemorixTargetFromDescriptor, } from "../mongo/target-config.js";
 import { parseDescriptorData } from "../descriptors/validate-descriptor.js";
 import { isMemorixCollectionIgnored, loadMemorixInventoryPolicy, } from "./inventory-policy.js";
+import { mongoPayloadSourceRef, objectTypeDescriptorSourceRef, runtimeProjectionSourceRef, } from "../runtime/source-provenance.js";
+import { countConfiguredTargets, countPhysicalDatabases, resolveMemorixTargetBindings, } from "../runtime/target-bindings.js";
 const XRONOX_DB_SOURCE = "_db";
+const DEFAULT_INVENTORY_SAMPLE_LIMIT = 3;
+const INVENTORY_SAMPLE_PREVIEW_FIELDS = [
+    "name",
+    "title",
+    "label",
+    "entityId",
+    "eventId",
+    "knowledgeId",
+    "recordId",
+    "id",
+];
 function resolveXronoxRole(client, target) {
     return client.xronoxRoles?.[target] ?? DEFAULT_MEMORIX_XRONOX_ROLES[target];
 }
@@ -37,34 +53,47 @@ function rowKey(databaseName, collectionName) {
 function makeRowId(target, databaseName, collectionName) {
     return `${target}:${databaseName}:${collectionName}`;
 }
+function normalizeMappingStatus(status) {
+    if (status === "object-missing")
+        return "object-type-missing";
+    return status;
+}
 function actionsForStatus(status, listable) {
+    const normalized = normalizeMappingStatus(status);
     const actions = [];
-    if (status === "mapped" || status === "collection-mismatch") {
-        actions.push(listable ? "open-records" : "open-raw-records");
+    if (normalized === "mapped" || normalized === "collection-mismatch") {
+        actions.push(listable ? "open-descriptor-backed-records" : "open-raw-records");
         actions.push("inspect-descriptor");
+        actions.push("inspect-collection");
     }
-    else if (status === "orphan-collection" || status === "unparseable") {
+    else if (normalized === "orphan-collection" || normalized === "unparseable") {
         actions.push("open-raw-records");
-        actions.push("create-descriptor");
+        actions.push("create-descriptor-draft");
+        actions.push("ask-user");
     }
-    else if (status === "missing-collection") {
+    else if (normalized === "missing-collection") {
         actions.push("inspect-descriptor");
-        actions.push("fix-binding");
+        actions.push("fix-binding-draft");
     }
-    else if (status === "object-missing" || status === "content-type-missing") {
-        actions.push("add-content-type");
-        actions.push("create-descriptor");
+    else if (normalized === "object-type-missing" ||
+        normalized === "content-type-missing") {
+        actions.push("add-content-type-draft");
+        actions.push("create-descriptor-draft");
+        actions.push("ask-user");
     }
-    if (status === "ignored")
-        actions.push("ignore");
+    if (normalized === "ignored")
+        actions.push("ignore-collection");
     return actions;
 }
 function issueSeverity(kind) {
     switch (kind) {
         case "empty-declared-collection":
+        case "target-db-not-configured":
+        case "target-db-empty":
             return "info";
         case "orphan-collection":
         case "collection-mismatch":
+        case "object-type-missing":
         case "object-missing":
         case "content-type-missing":
         case "unparseable-collection":
@@ -76,22 +105,152 @@ function issueSeverity(kind) {
 function suggestedActionsForKind(kind) {
     switch (kind) {
         case "missing-collection":
-            return ["inspect", "fix-binding"];
+            return ["inspect", "fix-binding-draft"];
         case "empty-declared-collection":
+        case "target-db-empty":
             return ["inspect"];
+        case "target-db-not-configured":
+            return ["inspect", "ask-user"];
         case "orphan-collection":
-            return ["inspect", "create-descriptor", "delete-or-archive"];
+            return ["inspect", "create-descriptor-draft", "delete-or-archive"];
+        case "object-type-missing":
         case "object-missing":
         case "content-type-missing":
-            return ["create-descriptor", "add-content-type"];
+            return ["create-descriptor-draft", "add-content-type-draft", "ask-user"];
         case "collection-mismatch":
-            return ["inspect", "fix-binding"];
+            return ["inspect", "fix-binding-draft"];
         case "unparseable-collection":
-            return ["inspect", "ignore"];
+            return ["inspect", "ignore-collection", "ask-user"];
         default:
             return ["inspect"];
     }
 }
+function requiredUserInputsForStatus(status, row) {
+    const normalized = normalizeMappingStatus(status);
+    if (normalized === "unparseable") {
+        return [
+            {
+                key: "objectType",
+                label: "Object type",
+                reason: "Collection name does not follow {objectName}-{contentType}.",
+                required: true,
+            },
+            {
+                key: "contentType",
+                label: "Content type",
+                reason: "Collection name does not expose content type.",
+                required: true,
+            },
+        ];
+    }
+    if (normalized === "object-type-missing") {
+        return [
+            {
+                key: "confirmObjectType",
+                label: "Confirm object type",
+                reason: `Parsed object type "${row.objectType ?? row.objectName}" does not exist in Catalox descriptors.`,
+                required: true,
+                options: ["create descriptor draft", "ignore collection"],
+            },
+        ];
+    }
+    return undefined;
+}
+function buildDescriptorRefs(slot, listDescriptorIds) {
+    if (!slot)
+        return {};
+    return {
+        objectTypeDescriptor: {
+            catalogId: MEMORIX_ENTITY_DESCRIPTORS_CATALOG,
+            itemId: slot.entityDescriptorId,
+        },
+        listDescriptors: listDescriptorIds?.map((itemId) => ({
+            catalogId: MEMORIX_LIST_DESCRIPTORS_CATALOG,
+            itemId,
+            kind: "entity",
+        })),
+        itemDescriptors: slot.defaultItemDescriptorId
+            ? [
+                {
+                    catalogId: MEMORIX_ITEM_DESCRIPTORS_CATALOG,
+                    itemId: slot.defaultItemDescriptorId,
+                },
+            ]
+            : undefined,
+        defaultListDescriptorId: slot.defaultListDescriptorId,
+        defaultItemDescriptorId: slot.defaultItemDescriptorId,
+    };
+}
+function buildLegacyDescriptor(descriptorRefs, listDescriptorIds) {
+    return {
+        entityDescriptorId: descriptorRefs.objectTypeDescriptor?.itemId,
+        listDescriptorIds,
+        defaultListDescriptorId: descriptorRefs.defaultListDescriptorId,
+        defaultItemDescriptorId: descriptorRefs.defaultItemDescriptorId,
+    };
+}
+function buildRowSourceRefs(client, input) {
+    const sources = [];
+    if (input.entityDescriptorId) {
+        sources.push(objectTypeDescriptorSourceRef(input.entityDescriptorId, {
+            appId: client.appId,
+            objectType: input.objectName,
+            target: input.target,
+        }));
+    }
+    if (input.rowSource === "mongo-discovered" || input.rowSource === "merged") {
+        sources.push(mongoPayloadSourceRef(input.target, input.databaseName, input.collectionName, {
+            appId: client.appId,
+            objectType: input.objectName,
+            contentType: input.contentType,
+        }));
+    }
+    const source = runtimeProjectionSourceRef("buildMemorixUnifiedInventory", {
+        appId: client.appId,
+    });
+    return { source, sources };
+}
+function buildInventoryRow(client, sourceLens, input) {
+    const objectName = input.objectName ?? "";
+    const objectType = objectName || undefined;
+    const descriptorRefs = buildDescriptorRefs(input.slot, input.listDescriptorIds);
+    const mappingStatus = normalizeMappingStatus(input.mappingStatus);
+    const { source, sources } = buildRowSourceRefs(client, {
+        rowSource: input.rowSource,
+        target: input.target,
+        databaseName: input.databaseName,
+        collectionName: input.collectionName,
+        objectName,
+        contentType: input.contentType,
+        entityDescriptorId: input.slot?.entityDescriptorId ?? descriptorRefs.objectTypeDescriptor?.itemId,
+    });
+    return {
+        rowId: input.rowId,
+        source,
+        sources,
+        rowSource: input.rowSource,
+        sourceLens,
+        target: input.target,
+        databaseName: input.databaseName,
+        objectName,
+        objectType,
+        entityName: objectType,
+        contentType: input.contentType,
+        collectionName: input.collectionName,
+        expectedCollectionName: input.expectedCollectionName,
+        parse: input.parse,
+        descriptorRefs,
+        descriptor: buildLegacyDescriptor(descriptorRefs, input.listDescriptorIds),
+        counts: input.counts,
+        mappingStatus,
+        actions: actionsForStatus(mappingStatus, input.listable),
+        requiredUserInputs: requiredUserInputsForStatus(mappingStatus, {
+            collectionName: input.collectionName,
+            objectName,
+            objectType,
+        }),
+    };
+}
 async function scanMongoCollections(client, targets, includeExactCounts) {
     const listCollections = requireXronoxListCollections(client);
     const countDocuments = requireXronoxCountDocuments(client);
@@ -210,8 +369,9 @@ function buildIssuesFromRows(rows) {
                 kind = "collection-mismatch";
                 message = `Collection "${row.collectionName}" does not match expected "${row.expectedCollectionName}"`;
                 break;
+            case "object-type-missing":
             case "object-missing":
-                kind = "object-missing";
+                kind = "object-type-missing";
                 message = `Parsed object "${row.objectName}" has no entity descriptor`;
                 break;
             case "content-type-missing":
@@ -233,14 +393,18 @@ function buildIssuesFromRows(rows) {
             issueId,
             severity: issueSeverity(kind),
             kind,
+            message,
+            source: row.source,
+            sources: row.sources,
             target: row.target,
             databaseName: row.databaseName,
-            objectName: row.objectName || undefined,
-            contentType: row.contentType || undefined,
+            objectType: row.objectType ?? row.objectName,
+            contentType: row.contentType,
             collectionName: row.collectionName,
-            descriptorId: row.descriptor?.entityDescriptorId,
-            message,
+            rowId: row.rowId,
+            descriptorId: row.descriptorRefs.objectTypeDescriptor?.itemId,
             suggestedActions: suggestedActionsForKind(kind),
+            requiredUserInputs: row.requiredUserInputs,
         });
         if (row.mappingStatus === "mapped" && (row.counts.exact === 0 || row.counts.estimated === 0)) {
             const emptyIssueId = `issue-${++counter}`;
@@ -249,13 +413,16 @@ function buildIssuesFromRows(rows) {
                 issueId: emptyIssueId,
                 severity: "info",
                 kind: "empty-declared-collection",
+                message: `Declared collection "${row.collectionName}" is empty`,
+                source: row.source,
+                sources: row.sources,
                 target: row.target,
                 databaseName: row.databaseName,
-                objectName: row.objectName,
+                objectType: row.objectType ?? row.objectName,
                 contentType: row.contentType,
                 collectionName: row.collectionName,
-                descriptorId: row.descriptor?.entityDescriptorId,
-                message: `Declared collection "${row.collectionName}" is empty`,
+                rowId: row.rowId,
+                descriptorId: row.descriptorRefs.objectTypeDescriptor?.itemId,
                 suggestedActions: ["inspect"],
             });
         }
@@ -266,7 +433,7 @@ function summarizeTargets(rows, targets, dbs) {
     const out = {};
     for (const target of ALL_MEMORIX_TARGETS) {
         const targetRows = rows.filter((r) => r.target === target);
-        const declared = targetRows.filter((r) => r.source !== "mongo-discovered");
+        const declared = targetRows.filter((r) => r.rowSource !== "mongo-discovered");
         out[target] = {
             databaseName: dbs[target],
             declaredCollections: declared.length,
@@ -275,7 +442,7 @@ function summarizeTargets(rows, targets, dbs) {
             orphanCollections: targetRows.filter((r) => r.mappingStatus === "orphan-collection").length,
             emptyDeclaredCollections: targetRows.filter((r) => r.mappingStatus === "mapped" &&
                 (r.counts.exact === 0 || r.counts.estimated === 0)).length,
-            mongoCollections: targetRows.filter((r) => r.source === "mongo-discovered" || r.source === "merged").length,
+            mongoCollections: targetRows.filter((r) => r.rowSource === "mongo-discovered" || r.rowSource === "merged").length,
             totalRecords: targetRows.reduce((sum, r) => sum + (r.counts.exact ?? r.counts.estimated ?? 0), 0),
         };
     }
@@ -294,6 +461,47 @@ function summarizeTargets(rows, targets, dbs) {
     }
     return out;
 }
+function buildSamplePreview(record, identityField) {
+    const preview = {};
+    for (const field of INVENTORY_SAMPLE_PREVIEW_FIELDS) {
+        const value = record[field];
+        if (value != null && typeof value !== "object") {
+            preview[field] = value;
+        }
+    }
+    if (identityField && record[identityField] != null) {
+        preview[identityField] = record[identityField];
+    }
+    return preview;
+}
+async function attachInventorySamples(client, rows) {
+    await Promise.all(rows.map(async (row) => {
+        if (!row.collectionName || row.mappingStatus === "missing-collection")
+            return;
+        const count = row.counts.exact ?? row.counts.estimated ?? 0;
+        if (count <= 0)
+            return;
+        try {
+            const docs = await memorixReadByTarget(client, {
+                target: row.target,
+                collection: row.collectionName,
+                limit: DEFAULT_INVENTORY_SAMPLE_LIMIT,
+            });
+            row.samples = docs.map((doc) => {
+                const serialized = serializeMemorixDocumentForJson(doc);
+                const identity = resolveMemorixRecordIdentity(row.target, serialized);
+                return {
+                    recordId: identity.recordId,
+                    identityField: identity.identityField,
+                    preview: buildSamplePreview(serialized, identity.identityField),
+                };
+            });
+        }
+        catch {
+            /* samples are optional enrichment */
+        }
+    }));
+}
 export async function buildMemorixUnifiedInventory(client, options = {}) {
     const sourceLens = options.sourceLens ?? "catalox-first";
     const targets = options.targets ?? [...ALL_MEMORIX_TARGETS];
@@ -324,14 +532,17 @@ export async function buildMemorixUnifiedInventory(client, options = {}) {
         if (!targets.includes(row.target))
             return;
         if (inventoryPolicy &&
+            row.collectionName &&
             isMemorixCollectionIgnored(inventoryPolicy, row.target, row.collectionName, row.databaseName)) {
             row.mappingStatus = "ignored";
-            row.actions = ["ignore"];
+            row.actions = ["ignore-collection"];
         }
         if (row.mappingStatus === "ignored" && !options.includeIgnored)
             return;
         rows.push(row);
-        seenKeys.add(rowKey(row.databaseName, row.collectionName));
+        if (row.databaseName && row.collectionName) {
+            seenKeys.add(rowKey(row.databaseName, row.collectionName));
+        }
     }
     if (sourceLens === "catalox-first") {
         for (const slot of declaredSlots) {
@@ -339,17 +550,10 @@ export async function buildMemorixUnifiedInventory(client, options = {}) {
             const scannedCol = scanned.get(key);
             const count = scannedCol?.count ?? 0;
             const exists = scannedCol != null;
-            let mappingStatus;
-            if (!exists) {
-                mappingStatus = "missing-collection";
-            }
-            else if (count > 0) {
-                mappingStatus = "mapped";
-            }
-            else {
-                mappingStatus = "mapped";
-            }
-            addRow({
+            const mappingStatus = !exists
+                ? "missing-collection"
+                : "mapped";
+            addRow(buildInventoryRow(client, sourceLens, {
                 rowId: makeRowId(slot.target, slot.databaseName, slot.collectionName),
                 target: slot.target,
                 databaseName: slot.databaseName,
@@ -357,20 +561,16 @@ export async function buildMemorixUnifiedInventory(client, options = {}) {
                 contentType: slot.contentType,
                 collectionName: slot.collectionName,
                 expectedCollectionName: slot.expectedCollectionName,
-                source: exists ? "merged" : "catalox-declared",
+                rowSource: exists ? "merged" : "catalox-declared",
                 mappingStatus,
-                descriptor: {
-                    entityDescriptorId: slot.entityDescriptorId,
-                    listDescriptorIds: listIdsByEntity.get(slot.objectName),
-                    defaultListDescriptorId: slot.defaultListDescriptorId,
-                    defaultItemDescriptorId: slot.defaultItemDescriptorId,
-                },
+                slot,
+                listDescriptorIds: listIdsByEntity.get(slot.objectName),
                 counts: {
                     ...(includeExactCounts ? { exact: count } : { estimated: count }),
                     countMode: exists ? countMode : "none",
                 },
-                actions: actionsForStatus(mappingStatus, slot.listable),
-            });
+                listable: slot.listable,
+            }));
         }
         for (const [key, col] of scanned) {
             if (declaredByKey.has(key))
@@ -393,21 +593,22 @@ export async function buildMemorixUnifiedInventory(client, options = {}) {
                     mappingStatus = col.count > 0 ? "orphan-collection" : "ignored";
                 }
             }
-            addRow({
+            addRow(buildInventoryRow(client, sourceLens, {
                 rowId: makeRowId(col.target, col.databaseName, col.collectionName),
                 target: col.target,
                 databaseName: col.databaseName,
                 objectName,
                 contentType,
                 collectionName: col.collectionName,
-                source: "mongo-discovered",
+                rowSource: "mongo-discovered",
                 mappingStatus,
                 counts: {
                     ...(includeExactCounts ? { exact: col.count } : { estimated: col.count }),
                     countMode,
                 },
-                actions: actionsForStatus(mappingStatus, false),
-            });
+                listable: false,
+                parse: parsed.ok ? parsed : parsed,
+            }));
         }
     }
     else {
@@ -415,7 +616,7 @@ export async function buildMemorixUnifiedInventory(client, options = {}) {
             const parsed = parseMemorixCollectionName(col.collectionName);
             const slot = declaredByKey.get(key);
             if (slot) {
-                addRow({
+                addRow(buildInventoryRow(client, sourceLens, {
                     rowId: makeRowId(col.target, col.databaseName, col.collectionName),
                     target: col.target,
                     databaseName: col.databaseName,
@@ -423,38 +624,36 @@ export async function buildMemorixUnifiedInventory(client, options = {}) {
                     contentType: slot.contentType,
                     collectionName: col.collectionName,
                     expectedCollectionName: slot.expectedCollectionName,
-                    source: "merged",
-                    mappingStatus: col.count > 0 ? "mapped" : "mapped",
-                    descriptor: {
-                        entityDescriptorId: slot.entityDescriptorId,
-                        listDescriptorIds: listIdsByEntity.get(slot.objectName),
-                        defaultListDescriptorId: slot.defaultListDescriptorId,
-                        defaultItemDescriptorId: slot.defaultItemDescriptorId,
-                    },
+                    rowSource: "merged",
+                    mappingStatus: "mapped",
+                    slot,
+                    listDescriptorIds: listIdsByEntity.get(slot.objectName),
                     counts: {
                         ...(includeExactCounts ? { exact: col.count } : { estimated: col.count }),
                         countMode,
                     },
-                    actions: actionsForStatus("mapped", slot.listable),
-                });
+                    listable: slot.listable,
+                    parse: parsed.ok ? parsed : undefined,
+                }));
                 continue;
             }
             if (!parsed.ok) {
-                addRow({
+                addRow(buildInventoryRow(client, sourceLens, {
                     rowId: makeRowId(col.target, col.databaseName, col.collectionName),
                     target: col.target,
                     databaseName: col.databaseName,
                     objectName: col.collectionName,
                     contentType: "",
                     collectionName: col.collectionName,
-                    source: "mongo-discovered",
+                    rowSource: "mongo-discovered",
                     mappingStatus: col.count > 0 ? "unparseable" : "ignored",
                     counts: {
                         ...(includeExactCounts ? { exact: col.count } : { estimated: col.count }),
                         countMode,
                     },
-                    actions: actionsForStatus("unparseable", false),
-                });
+                    listable: false,
+                    parse: parsed,
+                }));
                 continue;
             }
             const hasObject = objectNames.has(parsed.objectName);
@@ -471,27 +670,28 @@ export async function buildMemorixUnifiedInventory(client, options = {}) {
                     mappingStatus = col.count > 0 ? "orphan-collection" : "ignored";
                 }
             }
-            addRow({
+            addRow(buildInventoryRow(client, sourceLens, {
                 rowId: makeRowId(col.target, col.databaseName, col.collectionName),
                 target: col.target,
                 databaseName: col.databaseName,
                 objectName: parsed.objectName,
                 contentType: parsed.contentType,
                 collectionName: col.collectionName,
-                source: "mongo-discovered",
+                rowSource: "mongo-discovered",
                 mappingStatus,
                 counts: {
                     ...(includeExactCounts ? { exact: col.count } : { estimated: col.count }),
                     countMode,
                 },
-                actions: actionsForStatus(mappingStatus, false),
-            });
+                listable: false,
+                parse: parsed,
+            }));
         }
         for (const slot of declaredSlots) {
             const key = rowKey(slot.databaseName, slot.collectionName);
             if (seenKeys.has(key))
                 continue;
-            addRow({
+            addRow(buildInventoryRow(client, sourceLens, {
                 rowId: makeRowId(slot.target, slot.databaseName, slot.collectionName),
                 target: slot.target,
                 databaseName: slot.databaseName,
@@ -499,32 +699,62 @@ export async function buildMemorixUnifiedInventory(client, options = {}) {
                 contentType: slot.contentType,
                 collectionName: slot.collectionName,
                 expectedCollectionName: slot.expectedCollectionName,
-                source: "catalox-declared",
+                rowSource: "catalox-declared",
                 mappingStatus: "missing-collection",
-                descriptor: {
-                    entityDescriptorId: slot.entityDescriptorId,
-                    listDescriptorIds: listIdsByEntity.get(slot.objectName),
-                    defaultListDescriptorId: slot.defaultListDescriptorId,
-                    defaultItemDescriptorId: slot.defaultItemDescriptorId,
-                },
+                slot,
+                listDescriptorIds: listIdsByEntity.get(slot.objectName),
                 counts: { countMode: "none" },
-                actions: actionsForStatus("missing-collection", slot.listable),
-            });
+                listable: slot.listable,
+            }));
         }
     }
     rows.sort((a, b) => {
-        const db = a.databaseName.localeCompare(b.databaseName);
+        const db = (a.databaseName ?? "").localeCompare(b.databaseName ?? "");
         if (db !== 0)
             return db;
-        return a.collectionName.localeCompare(b.collectionName);
+        return (a.collectionName ?? "").localeCompare(b.collectionName ?? "");
     });
-    const issues = buildIssuesFromRows(rows);
+    if (options.includeSamples) {
+        await attachInventorySamples(client, rows);
+    }
+    const issues = options.includeIssues === false ? [] : buildIssuesFromRows(rows);
     const targetSummary = summarizeTargets(rows, targets, dbs);
-    const cataloxObjects = new Set(declaredSlots.map((s) => s.objectName)).size;
+    const targetBindings = await resolveMemorixTargetBindings(client, {
+        targets,
+        includeCounts: includeExactCounts,
+    });
+    const declaredObjectTypes = new Set(declaredSlots.map((s) => s.objectName)).size;
+    const inventorySource = runtimeProjectionSourceRef("buildMemorixUnifiedInventory", {
+        appId: client.appId,
+        sourceLens,
+    });
+    const warnings = [];
+    const errors = [];
+    for (const target of ALL_MEMORIX_TARGETS) {
+        const binding = targetBindings[target];
+        for (const warning of binding.warnings) {
+            warnings.push({
+                ...warning,
+                source: mongoPayloadSourceRef(target, binding.databaseName ?? binding.defaultDatabaseName, "_db", { appId: client.appId }),
+            });
+        }
+        for (const error of binding.errors) {
+            errors.push({
+                ...error,
+                source: mongoPayloadSourceRef(target, binding.databaseName ?? binding.defaultDatabaseName, "_db", { appId: client.appId }),
+            });
+        }
+    }
     return {
+        source: inventorySource,
         sourceLens,
+        generatedAt: new Date().toISOString(),
+        appId: client.appId,
+        targetBindings,
         summary: {
-            cataloxObjects,
+            declaredObjectTypes,
+            physicalDatabases: countPhysicalDatabases(targetBindings),
+            configuredTargets: countConfiguredTargets(targetBindings),
             mongoCollections: scanned.size,
             declaredCollections: declaredSlots.length,
             mappedCollections: rows.filter((r) => r.mappingStatus === "mapped").length,
@@ -532,13 +762,18 @@ export async function buildMemorixUnifiedInventory(client, options = {}) {
             orphanCollections: rows.filter((r) => r.mappingStatus === "orphan-collection").length,
             emptyDeclaredCollections: rows.filter((r) => r.mappingStatus === "mapped" &&
                 (r.counts.exact === 0 || r.counts.estimated === 0)).length,
+            collectionMismatches: rows.filter((r) => r.mappingStatus === "collection-mismatch").length,
+            unparseableCollections: rows.filter((r) => r.mappingStatus === "unparseable").length,
+            ignoredCollections: rows.filter((r) => r.mappingStatus === "ignored").length,
             totalRecords: rows.reduce((sum, r) => sum + (r.counts.exact ?? r.counts.estimated ?? 0), 0),
             issueCount: issues.length,
+            cataloxObjects: declaredObjectTypes,
         },
-        targets: targetSummary,
         rows,
         issues,
-        generatedAt: new Date().toISOString(),
+        warnings,
+        errors,
+        targets: targetSummary,
     };
 }
 //# sourceMappingURL=unified-inventory.js.map