@undefineds.co/xpod 0.2.0-preview.2 → 0.2.1

package/node_modules/@undefineds.co/drizzle-solid/dist/core/discovery/interop-discovery.js

@@ -0,0 +1,646 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InteropDiscovery = void 0;
+const interop_types_1 = require("./interop-types");
+const interop_tables_1 = require("./interop-tables");
+const helpers_1 = require("../sparql/helpers");
+const solid_client_1 = require("@inrupt/solid-client");
+const normalizeRdfClass = (value) => {
+    if (!value)
+        return value;
+    if (value.startsWith('http://schema.org/')) {
+        return value.replace('http://schema.org/', 'https://schema.org/');
+    }
+    return value;
+};
+class InteropDiscovery {
+    constructor(webId, fetchFn, clientId) {
+        this.webId = webId;
+        this.fetchFn = fetchFn;
+        this.clientId = clientId;
+        // Cache for ShapeTree -> Shape URL resolution
+        this.shapeTreeCache = new Map();
+    }
+    async ensureRegistrySet(profileDataset, profileThing, options) {
+        if (!options?.registryPath) {
+            throw new Error('Missing registryPath for SAI registry auto-creation.');
+        }
+        const registriesPath = options.registryPath.endsWith('/')
+            ? options.registryPath
+            : `${options.registryPath}/`;
+        const registriesParent = registriesPath.replace(/[^/]+\/$/, '');
+        const agentRegistryUrl = `${registriesPath}agents/`;
+        const setResourceUrl = `${registriesPath}set.ttl`;
+        const setId = 'set-drizzle-solid';
+        const registrySetUrl = `${setResourceUrl}#${setId}`;
+        const dataRegistryResourceUrl = `${registriesPath}data-registry.ttl`;
+        const dataRegistryId = 'data-registry';
+        const dataRegistryUrl = `${dataRegistryResourceUrl}#${dataRegistryId}`;
+        try {
+            if (registriesParent && registriesParent !== registriesPath) {
+                await (0, solid_client_1.createContainerAt)(registriesParent, { fetch: this.fetchFn });
+            }
+            await (0, solid_client_1.createContainerAt)(registriesPath, { fetch: this.fetchFn });
+        }
+        catch { }
+        try {
+            await (0, solid_client_1.createContainerAt)(agentRegistryUrl, { fetch: this.fetchFn });
+        }
+        catch { }
+        const dataRegistryThing = (0, solid_client_1.setUrl)((0, solid_client_1.createThing)({ url: dataRegistryUrl }), 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type', interop_types_1.INTEROP.DataRegistry);
+        let dataRegistryDataset;
+        try {
+            dataRegistryDataset = await (0, solid_client_1.getSolidDataset)(dataRegistryResourceUrl, { fetch: this.fetchFn });
+        }
+        catch {
+            dataRegistryDataset = undefined;
+        }
+        if (dataRegistryDataset) {
+            const existingThing = (0, solid_client_1.getThing)(dataRegistryDataset, dataRegistryUrl);
+            if (!existingThing) {
+                const updatedDataset = (0, solid_client_1.setThing)(dataRegistryDataset, dataRegistryThing);
+                await (0, solid_client_1.saveSolidDatasetAt)(dataRegistryResourceUrl, updatedDataset, { fetch: this.fetchFn });
+            }
+        }
+        else {
+            let newDataset = (0, solid_client_1.createSolidDataset)();
+            newDataset = (0, solid_client_1.setThing)(newDataset, dataRegistryThing);
+            await (0, solid_client_1.saveSolidDatasetAt)(dataRegistryResourceUrl, newDataset, { fetch: this.fetchFn });
+        }
+        let registrySetThing = (0, solid_client_1.createThing)({ url: registrySetUrl });
+        registrySetThing = (0, solid_client_1.setUrl)(registrySetThing, 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type', interop_types_1.INTEROP.RegistrySet);
+        registrySetThing = (0, solid_client_1.addUrl)(registrySetThing, interop_types_1.INTEROP.hasDataRegistry, dataRegistryUrl);
+        registrySetThing = (0, solid_client_1.addUrl)(registrySetThing, 'http://www.w3.org/ns/solid/interop#hasAgentRegistry', agentRegistryUrl);
+        let registrySetDataset;
+        try {
+            registrySetDataset = await (0, solid_client_1.getSolidDataset)(setResourceUrl, { fetch: this.fetchFn });
+        }
+        catch {
+            registrySetDataset = undefined;
+        }
+        if (registrySetDataset) {
+            const existingThing = (0, solid_client_1.getThing)(registrySetDataset, registrySetUrl);
+            if (!existingThing) {
+                const updatedDataset = (0, solid_client_1.setThing)(registrySetDataset, registrySetThing);
+                await (0, solid_client_1.saveSolidDatasetAt)(setResourceUrl, updatedDataset, { fetch: this.fetchFn });
+            }
+            else {
+                const hasDataRegistryPred = (0, helpers_1.getPredicateForColumn)(interop_tables_1.registrySetSchema.columns.hasDataRegistry, interop_tables_1.registrySetSchema);
+                const hasAgentRegistryPred = (0, helpers_1.getPredicateForColumn)(interop_tables_1.registrySetSchema.columns.hasAgentRegistry, interop_tables_1.registrySetSchema);
+                const dataRegistries = (0, solid_client_1.getUrlAll)(existingThing, hasDataRegistryPred);
+                const agentRegistries = (0, solid_client_1.getUrlAll)(existingThing, hasAgentRegistryPred);
+                let updatedThing = existingThing;
+                if (!dataRegistries.includes(dataRegistryUrl)) {
+                    updatedThing = (0, solid_client_1.addUrl)(updatedThing, hasDataRegistryPred, dataRegistryUrl);
+                }
+                if (!agentRegistries.includes(agentRegistryUrl)) {
+                    updatedThing = (0, solid_client_1.addUrl)(updatedThing, hasAgentRegistryPred, agentRegistryUrl);
+                }
+                if (updatedThing !== existingThing) {
+                    const updatedDataset = (0, solid_client_1.setThing)(registrySetDataset, updatedThing);
+                    await (0, solid_client_1.saveSolidDatasetAt)(setResourceUrl, updatedDataset, { fetch: this.fetchFn });
+                }
+            }
+        }
+        else {
+            let newDataset = (0, solid_client_1.createSolidDataset)();
+            newDataset = (0, solid_client_1.setThing)(newDataset, registrySetThing);
+            await (0, solid_client_1.saveSolidDatasetAt)(setResourceUrl, newDataset, { fetch: this.fetchFn });
+        }
+        const updatedProfileThing = (0, solid_client_1.setUrl)(profileThing, interop_types_1.INTEROP.hasRegistrySet, registrySetUrl);
+        const updatedProfileDataset = (0, solid_client_1.setThing)(profileDataset, updatedProfileThing);
+        const profileUrl = this.webId.split('#')[0];
+        await (0, solid_client_1.saveSolidDatasetAt)(profileUrl, updatedProfileDataset, { fetch: this.fetchFn });
+        return registrySetUrl;
+    }
+    async register(table, options) {
+        if (!options?.registryPath) {
+            throw new Error('registryPath is required for SAI registration.');
+        }
+        const rdfClass = typeof table.config.type === 'string' ? table.config.type : table.config.type.value;
+        const normalizedClass = normalizeRdfClass(rdfClass) ?? rdfClass;
+        try {
+            // 1. Ensure RegistrySet exists (auto-create if missing)
+            const profileDataset = await (0, solid_client_1.getSolidDataset)(this.webId, { fetch: this.fetchFn });
+            const profileThing = (0, solid_client_1.getThing)(profileDataset, this.webId);
+            if (!profileThing)
+                throw new Error('Profile not found');
+            let registrySetUrl = (0, solid_client_1.getUrl)(profileThing, interop_types_1.INTEROP.hasRegistrySet);
+            let registrySetDataset;
+            let registrySetThing;
+            if (registrySetUrl) {
+                try {
+                    registrySetDataset = await (0, solid_client_1.getSolidDataset)(registrySetUrl, { fetch: this.fetchFn });
+                    registrySetThing = (0, solid_client_1.getThing)(registrySetDataset, registrySetUrl);
+                }
+                catch {
+                    registrySetDataset = undefined;
+                    registrySetThing = undefined;
+                }
+            }
+            if (!registrySetUrl || !registrySetThing) {
+                registrySetUrl = await this.ensureRegistrySet(profileDataset, profileThing, options);
+                registrySetDataset = await (0, solid_client_1.getSolidDataset)(registrySetUrl, { fetch: this.fetchFn });
+                registrySetThing = (0, solid_client_1.getThing)(registrySetDataset, registrySetUrl);
+                if (!registrySetThing)
+                    throw new Error('RegistrySet not found');
+            }
+            // 2. Check if already registered (unless force is set)
+            if (!options?.force) {
+                const existing = await this.discover(rdfClass);
+                if (existing.length > 0) {
+                    console.log(`[InteropDiscovery] ${table.config.name} already registered, skipping`);
+                    return;
+                }
+            }
+            const dataRegistryPred = (0, helpers_1.getPredicateForColumn)(interop_tables_1.registrySetSchema.columns.hasDataRegistry, interop_tables_1.registrySetSchema);
+            const dataRegistryUrls = (0, solid_client_1.getUrlAll)(registrySetThing, dataRegistryPred);
+            if (dataRegistryUrls.length === 0)
+                throw new Error('No DataRegistry found');
+            const targetRegistryUrl = dataRegistryUrls[0];
+            // 3. Create DataRegistration Container
+            const slug = options?.containerSlug ?? table.config.name;
+            const registryContainer = targetRegistryUrl.endsWith('/') ? targetRegistryUrl : targetRegistryUrl + '/';
+            const dataContainerUrl = `${registryContainer}${slug}/`;
+            // Create data container if not exists
+            try {
+                await (0, solid_client_1.getSolidDataset)(dataContainerUrl, { fetch: this.fetchFn });
+            }
+            catch (e) {
+                await (0, solid_client_1.createContainerAt)(dataContainerUrl, { fetch: this.fetchFn });
+            }
+            const registrationResourceUrl = `${registryContainer}${slug}`;
+            // 4. Create ShapeTree (as a fragment in the same resource)
+            const shapeTreeUrl = `${registrationResourceUrl}#ShapeTree`;
+            let shapeTreeThing = (0, solid_client_1.createThing)({ url: shapeTreeUrl });
+            shapeTreeThing = (0, solid_client_1.setUrl)(shapeTreeThing, 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type', interop_types_1.SHAPETREES.ShapeTree);
+            shapeTreeThing = (0, solid_client_1.setUrl)(shapeTreeThing, interop_types_1.SHAPETREES.expectsType, normalizedClass);
+            // If Shape URL is provided, link it
+            if (options?.shapeUrl) {
+                shapeTreeThing = (0, solid_client_1.setUrl)(shapeTreeThing, interop_types_1.SHAPETREES.shape, options.shapeUrl);
+            }
+            // 5. Create DataRegistration
+            let registrationThing = (0, solid_client_1.createThing)({ url: registrationResourceUrl });
+            registrationThing = (0, solid_client_1.setUrl)(registrationThing, 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type', interop_types_1.INTEROP.DataRegistration);
+            // Use clientId when it looks like a URL, otherwise fallback to webId.
+            const registeredBy = this.clientId && /^https?:\/\//.test(this.clientId)
+                ? this.clientId
+                : this.webId;
+            registrationThing = (0, solid_client_1.setUrl)(registrationThing, interop_types_1.INTEROP.registeredBy, registeredBy);
+            registrationThing = (0, solid_client_1.setDatetime)(registrationThing, 'http://www.w3.org/ns/solid/interop#registeredAt', new Date());
+            registrationThing = (0, solid_client_1.setUrl)(registrationThing, interop_types_1.INTEROP.registeredShapeTree, shapeTreeUrl);
+            // Add subjectTemplate (UDFS extension)
+            const subjectTemplate = table.getSubjectTemplate();
+            if (subjectTemplate) {
+                registrationThing = (0, solid_client_1.setStringNoLocale)(registrationThing, interop_types_1.UDFS.subjectTemplate, subjectTemplate);
+            }
+            // 6. Save Registration Resource (contains both DataRegistration and ShapeTree)
+            // First try to get existing dataset, otherwise create a new empty one via save
+            let existingDataset;
+            try {
+                existingDataset = await (0, solid_client_1.getSolidDataset)(registrationResourceUrl, { fetch: this.fetchFn });
+            }
+            catch {
+                existingDataset = null;
+            }
+            let datasetToSave = existingDataset ?? (0, solid_client_1.createSolidDataset)();
+            let updated = false;
+            const existingRegistration = (0, solid_client_1.getThing)(datasetToSave, registrationResourceUrl);
+            if (!existingRegistration) {
+                datasetToSave = (0, solid_client_1.setThing)(datasetToSave, registrationThing);
+                updated = true;
+            }
+            else {
+                let updatedRegistration = existingRegistration;
+                const existingBy = (0, solid_client_1.getUrl)(existingRegistration, interop_types_1.INTEROP.registeredBy);
+                const existingShapeTree = (0, solid_client_1.getUrl)(existingRegistration, interop_types_1.INTEROP.registeredShapeTree);
+                const existingSubjectTemplate = (0, solid_client_1.getStringNoLocale)(existingRegistration, interop_types_1.UDFS.subjectTemplate);
+                if (!existingBy) {
+                    updatedRegistration = (0, solid_client_1.setUrl)(updatedRegistration, interop_types_1.INTEROP.registeredBy, registeredBy);
+                }
+                if (!existingShapeTree) {
+                    updatedRegistration = (0, solid_client_1.setUrl)(updatedRegistration, interop_types_1.INTEROP.registeredShapeTree, shapeTreeUrl);
+                }
+                if (!existingSubjectTemplate && subjectTemplate) {
+                    updatedRegistration = (0, solid_client_1.setStringNoLocale)(updatedRegistration, interop_types_1.UDFS.subjectTemplate, subjectTemplate);
+                }
+                if (updatedRegistration !== existingRegistration) {
+                    datasetToSave = (0, solid_client_1.setThing)(datasetToSave, updatedRegistration);
+                    updated = true;
+                }
+            }
+            const existingShapeTreeThing = (0, solid_client_1.getThing)(datasetToSave, shapeTreeUrl);
+            if (!existingShapeTreeThing) {
+                datasetToSave = (0, solid_client_1.setThing)(datasetToSave, shapeTreeThing);
+                updated = true;
+            }
+            if (!existingDataset || updated) {
+                await (0, solid_client_1.saveSolidDatasetAt)(registrationResourceUrl, datasetToSave, { fetch: this.fetchFn });
+            }
+            // 7. Link from DataRegistry
+            let registryDataset = await (0, solid_client_1.getSolidDataset)(targetRegistryUrl, { fetch: this.fetchFn });
+            let registryThing = (0, solid_client_1.getThing)(registryDataset, targetRegistryUrl);
+            if (!registryThing)
+                throw new Error('Registry Thing missing in Dataset');
+            const hasDataRegistrationPred = (0, helpers_1.getPredicateForColumn)(interop_tables_1.dataRegistrySchema.columns.hasDataRegistration, interop_tables_1.dataRegistrySchema);
+            registryThing = (0, solid_client_1.addUrl)(registryThing, hasDataRegistrationPred, registrationResourceUrl);
+            registryDataset = (0, solid_client_1.setThing)(registryDataset, registryThing);
+            await (0, solid_client_1.saveSolidDatasetAt)(targetRegistryUrl, registryDataset, { fetch: this.fetchFn });
+            // Update cache
+            this.shapeTreeCache.set(shapeTreeUrl, {
+                expectsType: normalizedClass,
+                shape: options?.shapeUrl
+            });
+            console.log(`[InteropDiscovery] Registered ${table.config.name} at ${registrationResourceUrl}`);
+            console.log(`[InteropDiscovery] -> ShapeTree: ${shapeTreeUrl}`);
+            console.log(`[InteropDiscovery] -> expectsType: ${normalizedClass}`);
+            if (options?.shapeUrl) {
+                console.log(`[InteropDiscovery] -> Shape: ${options.shapeUrl}`);
+            }
+        }
+        catch (e) {
+            console.error('[InteropDiscovery] Registration failed:', e);
+            throw e;
+        }
+    }
+    async discover(rdfClass, options) {
+        try {
+            const rawResults = [];
+            // 1. Fetch Profile
+            const profileDataset = await (0, solid_client_1.getSolidDataset)(this.webId, { fetch: this.fetchFn });
+            const profileThing = (0, solid_client_1.getThing)(profileDataset, this.webId);
+            if (!profileThing)
+                return [];
+            const registrySetUrls = (0, solid_client_1.getUrlAll)(profileThing, interop_types_1.INTEROP.hasRegistrySet);
+            if (registrySetUrls.length === 0) {
+                return [];
+            }
+            for (const registrySetUrl of registrySetUrls) {
+                // Strategy A: Direct Data Registration (Owner access)
+                const ownerResults = await this.discoverDataRegistrationsRaw(registrySetUrl, rdfClass, options);
+                rawResults.push(...ownerResults);
+                // Strategy B: Access Grants (Shared access)
+                const sharedResults = await this.discoverAccessGrantsRaw(registrySetUrl, rdfClass, options);
+                rawResults.push(...sharedResults);
+            }
+            // 按 container 合并结果
+            return this.mergeByContainer(rawResults);
+        }
+        catch (error) {
+            console.error('[InteropDiscovery] Discovery failed:', error);
+            return [];
+        }
+    }
+    /**
+     * 按 container 合并原始结果
+     * 同一个 container 的多个 Shape 合并到 shapes 数组中
+     */
+    mergeByContainer(rawResults) {
+        const containerMap = new Map();
+        for (const raw of rawResults) {
+            const existing = containerMap.get(raw.container);
+            const shapeInfo = raw.shape ? {
+                url: raw.shape,
+                shapeTree: raw.shapeTree,
+                registeredBy: raw.registeredBy,
+                source: raw.source
+            } : undefined;
+            if (existing) {
+                // 已有此 container，添加 shape 到数组（如果有且不重复）
+                if (shapeInfo && !existing.shapes.some(s => s.url === shapeInfo.url)) {
+                    existing.shapes.push(shapeInfo);
+                }
+                // Use subjectTemplate from first result that has it
+                if (!existing.subjectTemplate && raw.subjectTemplate) {
+                    existing.subjectTemplate = raw.subjectTemplate;
+                }
+            }
+            else {
+                // 新 container
+                containerMap.set(raw.container, {
+                    container: raw.container,
+                    subjectTemplate: raw.subjectTemplate,
+                    shapes: shapeInfo ? [shapeInfo] : [],
+                    source: raw.source
+                });
+            }
+        }
+        return Array.from(containerMap.values());
+    }
+    // ... (discoverDataRegistrations remains same)
+    async discoverDataRegistrationsRaw(registrySetUrl, rdfClass, options) {
+        const results = [];
+        const normalizedClass = normalizeRdfClass(rdfClass) ?? rdfClass;
+        try {
+            // Fetch RegistrySet
+            const registrySetDataset = await (0, solid_client_1.getSolidDataset)(registrySetUrl, { fetch: this.fetchFn });
+            const registrySetThing = (0, solid_client_1.getThing)(registrySetDataset, registrySetUrl);
+            if (!registrySetThing)
+                return [];
+            // Use predicate from Table Definition
+            const hasDataRegistryPred = (0, helpers_1.getPredicateForColumn)(interop_tables_1.registrySetSchema.columns.hasDataRegistry, interop_tables_1.registrySetSchema);
+            const dataRegistryUrls = (0, solid_client_1.getUrlAll)(registrySetThing, hasDataRegistryPred);
+            for (const registryUrl of dataRegistryUrls) {
+                try {
+                    const registryDataset = await (0, solid_client_1.getSolidDataset)(registryUrl, { fetch: this.fetchFn });
+                    const registryThing = (0, solid_client_1.getThing)(registryDataset, registryUrl);
+                    if (!registryThing)
+                        continue;
+                    const hasDataRegistrationPred = (0, helpers_1.getPredicateForColumn)(interop_tables_1.dataRegistrySchema.columns.hasDataRegistration, interop_tables_1.dataRegistrySchema);
+                    const registrationUrls = (0, solid_client_1.getUrlAll)(registryThing, hasDataRegistrationPred);
+                    for (const registrationUrl of registrationUrls) {
+                        const registrationDataset = await (0, solid_client_1.getSolidDataset)(registrationUrl, { fetch: this.fetchFn });
+                        const registrationThing = (0, solid_client_1.getThing)(registrationDataset, registrationUrl);
+                        if (!registrationThing)
+                            continue;
+                        const registeredShapeTreePred = (0, helpers_1.getPredicateForColumn)(interop_tables_1.dataRegistrationSchema.columns.registeredShapeTree, interop_tables_1.dataRegistrationSchema);
+                        const shapeTreeUrl = (0, solid_client_1.getUrl)(registrationThing, registeredShapeTreePred);
+                        if (!shapeTreeUrl)
+                            continue;
+                        // Get registeredBy for appId filtering
+                        const registeredByPred = (0, helpers_1.getPredicateForColumn)(interop_tables_1.dataRegistrationSchema.columns.registeredBy, interop_tables_1.dataRegistrationSchema);
+                        const registeredBy = (0, solid_client_1.getUrl)(registrationThing, registeredByPred);
+                        // Get subjectTemplate (UDFS extension)
+                        const subjectTemplate = (0, solid_client_1.getStringNoLocale)(registrationThing, interop_types_1.UDFS.subjectTemplate) ?? undefined;
+                        // Filter by appId if specified
+                        if (options?.appId && registeredBy !== options.appId) {
+                            continue;
+                        }
+                        const shapeTreeInfo = await this.resolveShapeTree(shapeTreeUrl);
+                        const matches = normalizeRdfClass(shapeTreeInfo?.expectsType) === normalizedClass;
+                        if (matches) {
+                            results.push({
+                                container: registrationUrl,
+                                source: 'interop',
+                                subjectTemplate,
+                                shapeTree: shapeTreeUrl,
+                                shape: shapeTreeInfo?.shape,
+                                registeredBy: registeredBy ?? undefined
+                            });
+                        }
+                    }
+                }
+                catch (e) {
+                    console.warn(`[InteropDiscovery] Error checking registry ${registryUrl}:`, e);
+                }
+            }
+        }
+        catch (e) {
+            console.warn(`[InteropDiscovery] Error exploring RegistrySet ${registrySetUrl}:`, e);
+        }
+        return results;
+    }
+    async discoverAccessGrantsRaw(registrySetUrl, rdfClass, options) {
+        if (!this.clientId) {
+            console.warn('[InteropDiscovery] No ClientID available, skipping Access Grant discovery');
+            return [];
+        }
+        const results = [];
+        const normalizedClass = normalizeRdfClass(rdfClass) ?? rdfClass;
+        try {
+            // 1. RegistrySet -> AgentRegistry
+            const registrySetDataset = await (0, solid_client_1.getSolidDataset)(registrySetUrl, { fetch: this.fetchFn });
+            const registrySetThing = (0, solid_client_1.getThing)(registrySetDataset, registrySetUrl);
+            if (!registrySetThing) {
+                console.warn(`[InteropDiscovery] RegistrySet Thing not found at ${registrySetUrl}`);
+                return [];
+            }
+            const agentRegistryPred = (0, helpers_1.getPredicateForColumn)(interop_tables_1.registrySetSchema.columns.hasAgentRegistry, interop_tables_1.registrySetSchema);
+            const agentRegistryUrls = (0, solid_client_1.getUrlAll)(registrySetThing, agentRegistryPred);
+            for (const agentRegistryUrl of agentRegistryUrls) {
+                try {
+                    const agentRegistryDataset = await (0, solid_client_1.getSolidDataset)(agentRegistryUrl, { fetch: this.fetchFn });
+                    const agentRegistryThing = (0, solid_client_1.getThing)(agentRegistryDataset, agentRegistryUrl);
+                    if (!agentRegistryThing)
+                        continue;
+                    // Find all candidate registration URLs: explicit links OR contained resources
+                    const hasAppRegPred = 'http://www.w3.org/ns/solid/interop#hasApplicationRegistration';
+                    const explicitAppRegs = (0, solid_client_1.getUrlAll)(agentRegistryThing, hasAppRegPred);
+                    const containedResources = (0, solid_client_1.getUrlAll)(agentRegistryThing, 'http://www.w3.org/ns/ldp#contains');
+                    const candidateUrls = Array.from(new Set([...explicitAppRegs, ...containedResources]));
+                    for (const candidateUrl of candidateUrls) {
+                        try {
+                            const regDataset = await (0, solid_client_1.getSolidDataset)(candidateUrl, { fetch: this.fetchFn });
+                            // Iterate all things in the resource to find the ApplicationRegistration
+                            const things = (0, solid_client_1.getThingAll)(regDataset);
+                            for (const regThing of things) {
+                                // Check registeredAgent
+                                const registeredAgentPred = (0, helpers_1.getPredicateForColumn)(interop_tables_1.applicationRegistrationSchema.columns.registeredAgent, interop_tables_1.applicationRegistrationSchema);
+                                const agent = (0, solid_client_1.getUrl)(regThing, registeredAgentPred);
+                                if (agent === this.clientId) {
+                                    const hasAccessGrantPred = (0, helpers_1.getPredicateForColumn)(interop_tables_1.applicationRegistrationSchema.columns.hasAccessGrant, interop_tables_1.applicationRegistrationSchema);
+                                    const accessGrantUrls = (0, solid_client_1.getUrlAll)(regThing, hasAccessGrantPred);
+                                    for (const grantUrl of accessGrantUrls) {
+                                        // Check if grant is in same dataset (common) or fetch
+                                        let grantThing = (0, solid_client_1.getThing)(regDataset, grantUrl);
+                                        if (!grantThing) {
+                                            const grantDataset = await (0, solid_client_1.getSolidDataset)(grantUrl, { fetch: this.fetchFn }).catch(() => null);
+                                            if (grantDataset)
+                                                grantThing = (0, solid_client_1.getThing)(grantDataset, grantUrl);
+                                        }
+                                        if (!grantThing)
+                                            continue;
+                                        const hasDataGrantPred = (0, helpers_1.getPredicateForColumn)(interop_tables_1.accessGrantSchema.columns.hasDataGrant, interop_tables_1.accessGrantSchema);
+                                        const dataGrantUrls = (0, solid_client_1.getUrlAll)(grantThing, hasDataGrantPred);
+                                        for (const dataGrantUrl of dataGrantUrls) {
+                                            // Same check for data grant
+                                            let dataGrantThing = (0, solid_client_1.getThing)(regDataset, dataGrantUrl);
+                                            if (!dataGrantThing) {
+                                                const dataGrantDataset = await (0, solid_client_1.getSolidDataset)(dataGrantUrl, { fetch: this.fetchFn }).catch(() => null);
+                                                if (dataGrantDataset)
+                                                    dataGrantThing = (0, solid_client_1.getThing)(dataGrantDataset, dataGrantUrl);
+                                            }
+                                            if (!dataGrantThing)
+                                                continue;
+                                            const shapeTreePred = (0, helpers_1.getPredicateForColumn)(interop_tables_1.dataGrantSchema.columns.registeredShapeTree, interop_tables_1.dataGrantSchema);
+                                            const shapeTreeUrl = (0, solid_client_1.getUrl)(dataGrantThing, shapeTreePred);
+                                            if (!shapeTreeUrl)
+                                                continue;
+                                            // Get data owner for registeredBy
+                                            const dataOwnerPred = (0, helpers_1.getPredicateForColumn)(interop_tables_1.dataGrantSchema.columns.dataOwner, interop_tables_1.dataGrantSchema);
+                                            const dataOwner = (0, solid_client_1.getUrl)(dataGrantThing, dataOwnerPred);
+                                            // Filter by appId if specified (here appId refers to data owner/registrant)
+                                            if (options?.appId && dataOwner !== options.appId) {
+                                                continue;
+                                            }
+                                            const shapeTreeInfo = await this.resolveShapeTree(shapeTreeUrl);
+                                            const matches = normalizeRdfClass(shapeTreeInfo?.expectsType) === normalizedClass;
+                                            if (matches) {
+                                                const hasDataRegistrationPred = (0, helpers_1.getPredicateForColumn)(interop_tables_1.dataGrantSchema.columns.hasDataRegistration, interop_tables_1.dataGrantSchema);
+                                                const registrationUrl = (0, solid_client_1.getUrl)(dataGrantThing, hasDataRegistrationPred);
+                                                console.log(`[InteropDiscovery] Found matching Data Grant: ${dataGrantUrl}`);
+                                                console.log(`[InteropDiscovery] -> ShapeTree: ${shapeTreeUrl}`);
+                                                console.log(`[InteropDiscovery] -> Shape: ${shapeTreeInfo?.shape}`);
+                                                console.log(`[InteropDiscovery] -> Data Registration: ${registrationUrl}`);
+                                                if (registrationUrl) {
+                                                    results.push({
+                                                        container: registrationUrl,
+                                                        source: 'interop',
+                                                        shapeTree: shapeTreeUrl,
+                                                        shape: shapeTreeInfo?.shape,
+                                                        registeredBy: dataOwner ?? undefined
+                                                    });
+                                                }
+                                            }
+                                            else {
+                                                console.log(`[InteropDiscovery] ShapeTree mismatch: ${shapeTreeUrl} vs ${rdfClass}`);
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        catch (e) {
+                            // Ignore individual registration fetch errors
+                        }
+                    }
+                }
+                catch (e) {
+                    console.warn(`[InteropDiscovery] Error checking AgentRegistry ${agentRegistryUrl}:`, e);
+                }
+            }
+        }
+        catch (e) {
+            console.warn(`[InteropDiscovery] Error in AccessGrant discovery:`, e);
+        }
+        return results;
+    }
+    async isRegistered(rdfClass) {
+        const locations = await this.discover(rdfClass);
+        return locations.length > 0;
+    }
+    /**
+     * 按应用 ID 发现所有数据位置
+     * @param appId 应用标识符
+     */
+    async discoverByApp(appId) {
+        try {
+            const allRegistrations = await this.discoverAll();
+            const filtered = allRegistrations.filter(reg => reg.registeredBy === appId);
+            // 转换为 RawDiscoveryResult 然后合并
+            const rawResults = filtered.map(reg => ({
+                container: reg.container,
+                source: 'interop',
+                shapeTree: reg.shapeTree,
+                shape: reg.shape,
+                registeredBy: reg.registeredBy
+            }));
+            return this.mergeByContainer(rawResults);
+        }
+        catch (error) {
+            console.error('[InteropDiscovery] discoverByApp failed:', error);
+            return [];
+        }
+    }
+    /**
+     * 获取所有数据注册
+     */
+    async discoverAll() {
+        const registrations = [];
+        try {
+            // 1. Fetch Profile
+            const profileDataset = await (0, solid_client_1.getSolidDataset)(this.webId, { fetch: this.fetchFn });
+            const profileThing = (0, solid_client_1.getThing)(profileDataset, this.webId);
+            if (!profileThing)
+                return [];
+            const registrySetUrls = (0, solid_client_1.getUrlAll)(profileThing, interop_types_1.INTEROP.hasRegistrySet);
+            for (const registrySetUrl of registrySetUrls) {
+                try {
+                    const registrySetDataset = await (0, solid_client_1.getSolidDataset)(registrySetUrl, { fetch: this.fetchFn });
+                    const registrySetThing = (0, solid_client_1.getThing)(registrySetDataset, registrySetUrl);
+                    if (!registrySetThing)
+                        continue;
+                    const hasDataRegistryPred = (0, helpers_1.getPredicateForColumn)(interop_tables_1.registrySetSchema.columns.hasDataRegistry, interop_tables_1.registrySetSchema);
+                    const dataRegistryUrls = (0, solid_client_1.getUrlAll)(registrySetThing, hasDataRegistryPred);
+                    for (const registryUrl of dataRegistryUrls) {
+                        try {
+                            const registryDataset = await (0, solid_client_1.getSolidDataset)(registryUrl, { fetch: this.fetchFn });
+                            const registryThing = (0, solid_client_1.getThing)(registryDataset, registryUrl);
+                            if (!registryThing)
+                                continue;
+                            const hasDataRegistrationPred = (0, helpers_1.getPredicateForColumn)(interop_tables_1.dataRegistrySchema.columns.hasDataRegistration, interop_tables_1.dataRegistrySchema);
+                            const registrationUrls = (0, solid_client_1.getUrlAll)(registryThing, hasDataRegistrationPred);
+                            for (const registrationUrl of registrationUrls) {
+                                try {
+                                    const registrationDataset = await (0, solid_client_1.getSolidDataset)(registrationUrl, { fetch: this.fetchFn });
+                                    const registrationThing = (0, solid_client_1.getThing)(registrationDataset, registrationUrl);
+                                    if (!registrationThing)
+                                        continue;
+                                    const registeredShapeTreePred = (0, helpers_1.getPredicateForColumn)(interop_tables_1.dataRegistrationSchema.columns.registeredShapeTree, interop_tables_1.dataRegistrationSchema);
+                                    const shapeTreeUrl = (0, solid_client_1.getUrl)(registrationThing, registeredShapeTreePred);
+                                    if (!shapeTreeUrl)
+                                        continue;
+                                    const registeredByPred = (0, helpers_1.getPredicateForColumn)(interop_tables_1.dataRegistrationSchema.columns.registeredBy, interop_tables_1.dataRegistrationSchema);
+                                    const registeredBy = (0, solid_client_1.getUrl)(registrationThing, registeredByPred);
+                                    const registeredAtPred = (0, helpers_1.getPredicateForColumn)(interop_tables_1.dataRegistrationSchema.columns.registeredAt, interop_tables_1.dataRegistrationSchema);
+                                    const registeredAtStr = (0, solid_client_1.getUrl)(registrationThing, registeredAtPred);
+                                    const registeredAt = registeredAtStr ? new Date(registeredAtStr) : undefined;
+                                    // Get subjectTemplate (UDFS extension)
+                                    const subjectTemplate = (0, solid_client_1.getStringNoLocale)(registrationThing, interop_types_1.UDFS.subjectTemplate) ?? undefined;
+                                    const shapeTreeInfo = await this.resolveShapeTree(shapeTreeUrl);
+                                    registrations.push({
+                                        registrationUrl,
+                                        container: registrationUrl,
+                                        rdfClass: shapeTreeInfo?.expectsType ?? '',
+                                        shapeTree: shapeTreeUrl,
+                                        shape: shapeTreeInfo?.shape,
+                                        subjectTemplate,
+                                        registeredBy: registeredBy ?? undefined,
+                                        registeredAt
+                                    });
+                                }
+                                catch (e) {
+                                    console.warn(`[InteropDiscovery] Error reading registration ${registrationUrl}:`, e);
+                                }
+                            }
+                        }
+                        catch (e) {
+                            console.warn(`[InteropDiscovery] Error reading registry ${registryUrl}:`, e);
+                        }
+                    }
+                }
+                catch (e) {
+                    console.warn(`[InteropDiscovery] Error reading RegistrySet ${registrySetUrl}:`, e);
+                }
+            }
+        }
+        catch (error) {
+            console.error('[InteropDiscovery] discoverAll failed:', error);
+        }
+        return registrations;
+    }
+    async checkShapeTreeMatchesClass(shapeTreeUrl, rdfClass) {
+        const info = await this.resolveShapeTree(shapeTreeUrl);
+        return normalizeRdfClass(info?.expectsType) === (normalizeRdfClass(rdfClass) ?? rdfClass);
+    }
+    /**
+     * 解析 ShapeTree，获取 expectsType 和 shape URL
+     * 结果会被缓存以提高性能
+     */
+    async resolveShapeTree(shapeTreeUrl) {
+        // Check cache first
+        if (this.shapeTreeCache.has(shapeTreeUrl)) {
+            return this.shapeTreeCache.get(shapeTreeUrl);
+        }
+        try {
+            const shapeTreeDataset = await (0, solid_client_1.getSolidDataset)(shapeTreeUrl, { fetch: this.fetchFn });
+            const shapeTreeThing = (0, solid_client_1.getThing)(shapeTreeDataset, shapeTreeUrl);
+            if (!shapeTreeThing) {
+                this.shapeTreeCache.set(shapeTreeUrl, {});
+                return null;
+            }
+            const expectsType = (0, solid_client_1.getUrl)(shapeTreeThing, interop_types_1.SHAPETREES.expectsType) ?? undefined;
+            const shape = (0, solid_client_1.getUrl)(shapeTreeThing, interop_types_1.SHAPETREES.shape) ?? undefined;
+            const result = { expectsType, shape };
+            this.shapeTreeCache.set(shapeTreeUrl, result);
+            return result;
+        }
+        catch (e) {
+            console.warn(`[InteropDiscovery] Failed to fetch ShapeTree ${shapeTreeUrl}:`, e);
+            this.shapeTreeCache.set(shapeTreeUrl, {});
+            return null;
+        }
+    }
+}
+exports.InteropDiscovery = InteropDiscovery;
+//# sourceMappingURL=interop-discovery.js.map