gdc-sdk-node-ts 0.8.1 → 0.8.3

package/README.md

@@ -191,7 +191,8 @@ Documentation consistency rule for this repo family:
 Use the Node discovery layer when your backend or BFF needs to:
 
 - start from preloaded hosting-operator semantics
-- fetch the canonical `/.well-known/dspace-version` entrypoint
+- fetch the canonical host-scoped
+  `/<hosting-operator-network-context>/.well-known/dspace-version` entrypoint
 - derive the participant-scoped `/dsp/catalog/dcat.json` artifact
 - return normalized provider/operator matches to portal or app backends
 
@@ -203,6 +204,11 @@ Primary references:
 - [tests/dataspace-resolver-advanced.test.mjs](tests/dataspace-resolver-advanced.test.mjs)
 - [tests/dataspace-resolver.test.mjs](tests/dataspace-resolver.test.mjs)
 
+Architecture note:
+
+- the reusable discovery resolver logic lives in `gdc-sdk-core-ts`
+- `gdc-sdk-node-ts` re-exports it and supplies the Node runtime surface
+
 Copy/paste starting point:
 
 ```ts

package/dist/discovery/DataspaceResolver.d.ts

@@ -1,24 +1 @@
-import type { HostingOperatorMatch, PublishedProviderMatch, ResolveHostingOperatorsInput, ResolvePublishedProvidersInput } from './types.js';
-/**
- * Backend/BFF-facing abstraction for dataspace discovery resolution.
- *
- * Responsibility boundary:
- * - node runtimes orchestrate VC parsing, host-catalog fetch, and capability
- *   filtering
- * - semantic extraction and EU coverage inference come from
- *   `gdc-common-utils-ts`
- * - tenant-host linkage is resolved from host public catalogs, not from private
- *   tenant VC fields
- */
-export declare abstract class DataspaceResolver {
-    /**
-     * Resolves hosting operators whose semantic service metadata matches the
-     * requested sector, capability set, and optional coverage dimensions.
-     */
-    abstract resolveHostingOperators(input: ResolveHostingOperatorsInput): Promise<HostingOperatorMatch[]>;
-    /**
-     * Resolves publicly published provider offerings starting from eligible
-     * hosting operators and their public discovery catalogs.
-     */
-    abstract resolvePublishedProviders(input: ResolvePublishedProvidersInput): Promise<PublishedProviderMatch[]>;
-}
+export { DataspaceResolver } from 'gdc-sdk-core-ts';

package/dist/discovery/DataspaceResolver.js

@@ -1,14 +1,2 @@
 // Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
-/**
- * Backend/BFF-facing abstraction for dataspace discovery resolution.
- *
- * Responsibility boundary:
- * - node runtimes orchestrate VC parsing, host-catalog fetch, and capability
- *   filtering
- * - semantic extraction and EU coverage inference come from
- *   `gdc-common-utils-ts`
- * - tenant-host linkage is resolved from host public catalogs, not from private
- *   tenant VC fields
- */
-export class DataspaceResolver {
-}
+export { DataspaceResolver } from 'gdc-sdk-core-ts';

package/dist/discovery/DefaultFirstDataspaceDiscovery.d.ts

@@ -1,44 +1 @@
-import type { DefaultFirstDataspaceDiscoveryOptions, GetDataspaceHostsInput, HostingOperatorMatch, PublishedProviderMatch, SimpleDataspaceDiscoveryRequest } from './types.js';
-/**
- * High-level default-first discovery facade for portal/backend integrations.
- *
- * Intended usage:
- * - configure ICA/hosting defaults once during backend startup
- * - later ask simple questions per request:
- *   - `getHosts({ sector, jurisdiction })`
- *   - `getIndexProviders({ sector, jurisdiction })`
- *   - `getDigitalTwinProviders({ sector, jurisdiction })`
- *
- * The facade keeps the bootstrap-plan plumbing internal so app code does not
- * need to understand the lower-level defaults registry or resolver wiring.
- */
-export declare class DefaultFirstDataspaceDiscovery {
-    private readonly defaultsRegistry;
-    private readonly version;
-    private readonly networkType;
-    private readonly fetcher?;
-    constructor(options: DefaultFirstDataspaceDiscoveryOptions);
-    /**
-     * Returns matching hosting operators for one `sector + jurisdiction`
-     * request using the configured default-first bootstrap policy.
-     */
-    getHosts(input: GetDataspaceHostsInput): Promise<HostingOperatorMatch[]>;
-    /**
-     * Returns published `IndexProvider` services for one `sector + jurisdiction`
-     * request.
-     */
-    getIndexProviders(input: SimpleDataspaceDiscoveryRequest): Promise<PublishedProviderMatch[]>;
-    /**
-     * Returns published `DigitalTwinProvider` services for one
-     * `sector + jurisdiction` request.
-     */
-    getDigitalTwinProviders(input: SimpleDataspaceDiscoveryRequest): Promise<PublishedProviderMatch[]>;
-    private getProviders;
-    private createResolver;
-    private buildBootstrapPlan;
-    private resolveDefaultPublishedProviders;
-}
-/**
- * Convenience factory for the default-first portal/backend discovery facade.
- */
-export declare function createDefaultFirstDataspaceDiscovery(options: DefaultFirstDataspaceDiscoveryOptions): DefaultFirstDataspaceDiscovery;
+export { DefaultFirstDataspaceDiscovery, createDefaultFirstDataspaceDiscovery, } from 'gdc-sdk-core-ts';

package/dist/discovery/DefaultFirstDataspaceDiscovery.js

@@ -1,163 +1,2 @@
 // Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
-import { DataspaceCoverageScope, DataspaceDiscoverySourceMode, ServiceCapabilityToken, createDataspaceDiscoveryDefaultsRegistry, DataspaceProtocolVersions, inferCoverageScopeFromCountryCode, isProviderServiceCapability, normalizeCountryCode, } from 'gdc-common-utils-ts';
-import { HttpDataspaceResolver } from './HttpDataspaceResolver.js';
-function normalizeString(value) {
-    return typeof value === 'string' ? value.trim() : '';
-}
-function equalsIgnoreCase(left, right) {
-    return left.trim().toLowerCase() === right.trim().toLowerCase();
-}
-function splitTokens(value) {
-    if (Array.isArray(value)) {
-        return value.map((entry) => normalizeString(entry)).filter(Boolean);
-    }
-    const raw = normalizeString(value);
-    if (!raw)
-        return [];
-    return raw.split(',').map((entry) => entry.trim()).filter(Boolean);
-}
-function buildCoverageTokens(areaServed, filterJurisdiction) {
-    const tokens = new Set(splitTokens(areaServed).map((token) => token.toUpperCase()));
-    const normalizedJurisdiction = normalizeCountryCode(filterJurisdiction);
-    if (normalizedJurisdiction) {
-        const inferred = inferCoverageScopeFromCountryCode(normalizedJurisdiction);
-        if (inferred)
-            tokens.add(inferred.toUpperCase());
-    }
-    return tokens;
-}
-function matchesProviderCoverage(provider, jurisdiction, coverageScope) {
-    const normalizedJurisdiction = normalizeCountryCode(jurisdiction);
-    const normalizedCoverageScope = normalizeString(coverageScope).toUpperCase();
-    if (!normalizedJurisdiction && !normalizedCoverageScope)
-        return true;
-    const tokens = buildCoverageTokens(provider.areaServed, jurisdiction);
-    if (normalizedJurisdiction && tokens.has(normalizedJurisdiction))
-        return true;
-    if (normalizedCoverageScope && tokens.has(normalizedCoverageScope))
-        return true;
-    if (normalizedCoverageScope === DataspaceCoverageScope.EuropeanUnion) {
-        return Array.from(tokens).some((token) => inferCoverageScopeFromCountryCode(token) === DataspaceCoverageScope.EuropeanUnion);
-    }
-    return false;
-}
-function matchesDefaultPublishedProvider(provider, input, providerCapability) {
-    if (!equalsIgnoreCase(provider.category, input.sector))
-        return false;
-    if (!isProviderServiceCapability(provider.serviceType))
-        return false;
-    if (!equalsIgnoreCase(provider.serviceType, providerCapability))
-        return false;
-    if (!matchesProviderCoverage(provider, input.jurisdiction, input.coverageScope))
-        return false;
-    return true;
-}
-function isDefaultsRegistry(value) {
-    return Boolean(value)
-        && typeof value === 'object'
-        && 'buildBootstrapPlan' in value
-        && typeof value.buildBootstrapPlan === 'function';
-}
-/**
- * High-level default-first discovery facade for portal/backend integrations.
- *
- * Intended usage:
- * - configure ICA/hosting defaults once during backend startup
- * - later ask simple questions per request:
- *   - `getHosts({ sector, jurisdiction })`
- *   - `getIndexProviders({ sector, jurisdiction })`
- *   - `getDigitalTwinProviders({ sector, jurisdiction })`
- *
- * The facade keeps the bootstrap-plan plumbing internal so app code does not
- * need to understand the lower-level defaults registry or resolver wiring.
- */
-export class DefaultFirstDataspaceDiscovery {
-    constructor(options) {
-        this.defaultsRegistry = isDefaultsRegistry(options.defaults)
-            ? options.defaults
-            : createDataspaceDiscoveryDefaultsRegistry(options.defaults);
-        this.version = normalizeString(options.version) || DataspaceProtocolVersions.Current;
-        this.networkType = normalizeString(options.networkType);
-        this.fetcher = options.fetcher;
-    }
-    /**
-     * Returns matching hosting operators for one `sector + jurisdiction`
-     * request using the configured default-first bootstrap policy.
-     */
-    async getHosts(input) {
-        const resolver = this.createResolver(input, input.requiredCapabilities || []);
-        return resolver.resolveHostingOperators({
-            sector: input.sector,
-            jurisdiction: input.jurisdiction,
-            coverageScope: input.coverageScope,
-            requiredCapabilities: [...(input.requiredCapabilities || [])],
-        });
-    }
-    /**
-     * Returns published `IndexProvider` services for one `sector + jurisdiction`
-     * request.
-     */
-    async getIndexProviders(input) {
-        return this.getProviders(input, ServiceCapabilityToken.IndexProvider);
-    }
-    /**
-     * Returns published `DigitalTwinProvider` services for one
-     * `sector + jurisdiction` request.
-     */
-    async getDigitalTwinProviders(input) {
-        return this.getProviders(input, ServiceCapabilityToken.DigitalTwinProvider);
-    }
-    async getProviders(input, providerCapability) {
-        const bootstrapPlan = this.buildBootstrapPlan(input, [providerCapability]);
-        const defaultPublishedProviders = this.resolveDefaultPublishedProviders(bootstrapPlan.hostingOperators, input, providerCapability);
-        if (defaultPublishedProviders.length > 0) {
-            return defaultPublishedProviders;
-        }
-        const resolver = new HttpDataspaceResolver({
-            hostingOperators: bootstrapPlan.hostingOperators,
-            fetcher: this.fetcher,
-        });
-        return resolver.resolvePublishedProviders({
-            sector: input.sector,
-            jurisdiction: input.jurisdiction,
-            coverageScope: input.coverageScope,
-            providerCapability,
-        });
-    }
-    createResolver(input, requiredCapabilities) {
-        const bootstrapPlan = this.buildBootstrapPlan(input, requiredCapabilities);
-        return new HttpDataspaceResolver({
-            hostingOperators: bootstrapPlan.hostingOperators,
-            fetcher: this.fetcher,
-        });
-    }
-    buildBootstrapPlan(input, requiredCapabilities) {
-        return this.defaultsRegistry.buildBootstrapPlan({
-            jurisdiction: input.jurisdiction,
-            version: this.version,
-            networkType: this.networkType,
-            sector: input.sector,
-            coverageScope: input.coverageScope,
-            requiredCapabilities,
-            sourceMode: DataspaceDiscoverySourceMode.DefaultFirst,
-        });
-    }
-    resolveDefaultPublishedProviders(hosts, input, providerCapability) {
-        return hosts.flatMap((host) => (host.publishedProviders || [])
-            .filter((provider) => matchesDefaultPublishedProvider(provider, input, providerCapability))
-            .map((provider) => ({
-            providerDid: provider.providerDid,
-            record: provider,
-            hostingOperator: host.record,
-            hostingOperatorDid: host.operatorDid,
-            discoveryUrl: provider.discoveryUrl || host.discoveryUrl,
-            catalogUrl: provider.catalogUrl || host.catalogUrl,
-        })));
-    }
-}
-/**
- * Convenience factory for the default-first portal/backend discovery facade.
- */
-export function createDefaultFirstDataspaceDiscovery(options) {
-    return new DefaultFirstDataspaceDiscovery(options);
-}
+export { DefaultFirstDataspaceDiscovery, createDefaultFirstDataspaceDiscovery, } from 'gdc-sdk-core-ts';

package/dist/discovery/HttpDataspaceResolver.d.ts

@@ -1,30 +1 @@
-import { DataspaceResolver } from './DataspaceResolver.js';
-import type { HostingOperatorMatch, HttpDataspaceResolverOptions, PublishedProviderMatch, ResolveHostingOperatorsInput, ResolvePublishedProvidersInput } from './types.js';
-/**
- * Concrete node/BFF resolver that combines preloaded hosting-operator records
- * with each host's public service-autodiscovery catalog.
- */
-export declare class HttpDataspaceResolver extends DataspaceResolver {
-    private readonly hostingOperators;
-    private readonly fetcher;
-    constructor(options: HttpDataspaceResolverOptions);
-    /**
-     * Resolves hosting operators from the preloaded semantic records.
-     */
-    resolveHostingOperators(input: ResolveHostingOperatorsInput): Promise<HostingOperatorMatch[]>;
-    /**
-     * Resolves published providers by fetching and filtering eligible host public
-     * discovery catalogs.
-     */
-    resolvePublishedProviders(input: ResolvePublishedProvidersInput): Promise<PublishedProviderMatch[]>;
-    /**
-     * Fetches a public discovery catalog for a hosting operator.
-     *
-     * Resolution order:
-     * - canonical DSP entrypoint via `discoveryUrl` (`/.well-known/dspace-version`)
-     * - direct catalog artifact compatibility via `catalogUrl`
-     */
-    private fetchCatalog;
-    private resolveCatalogArtifactUrl;
-    private fetchDspaceVersionMetadata;
-}
+export { HttpDataspaceResolver } from 'gdc-sdk-core-ts';

package/dist/discovery/HttpDataspaceResolver.js

@@ -1,231 +1,2 @@
 // Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
-import { DataspaceCoverageScope, DataspaceProtocolVersions, DataspaceWellKnownPaths, deriveGwCatalogArtifactUrlFromDspaceVersion, inferCoverageScopeFromCountryCode, isProviderServiceCapability, normalizeCountryCode, } from 'gdc-common-utils-ts';
-import { DataspaceResolver } from './DataspaceResolver.js';
-function isObject(value) {
-    return !!value && typeof value === 'object' && !Array.isArray(value);
-}
-function asString(value) {
-    return typeof value === 'string' ? value.trim() : '';
-}
-function equalsIgnoreCase(left, right) {
-    return left.trim().toLowerCase() === right.trim().toLowerCase();
-}
-function splitTokens(value) {
-    if (Array.isArray(value)) {
-        return value.map((entry) => asString(entry)).filter(Boolean);
-    }
-    const raw = typeof value === 'string' ? value : '';
-    if (!raw)
-        return [];
-    return raw.split(',').map((entry) => entry.trim()).filter(Boolean);
-}
-function hasAllTokens(values, requiredValues) {
-    if (!requiredValues?.length)
-        return true;
-    const normalizedValues = new Set((values || []).map((value) => value.trim().toLowerCase()).filter(Boolean));
-    return requiredValues.every((requiredValue) => normalizedValues.has(requiredValue.trim().toLowerCase()));
-}
-function matchSectorValues(values, sector) {
-    if (!sector)
-        return true;
-    return (values || []).some((value) => equalsIgnoreCase(value, sector));
-}
-function buildCoverageTokens(recordCountry, areaServed, coverageScope) {
-    const tokens = new Set();
-    splitTokens(areaServed).forEach((token) => tokens.add(token.toUpperCase()));
-    const normalizedCountry = normalizeCountryCode(recordCountry);
-    if (normalizedCountry) {
-        tokens.add(normalizedCountry);
-        const inferred = inferCoverageScopeFromCountryCode(normalizedCountry);
-        if (inferred)
-            tokens.add(inferred.toUpperCase());
-    }
-    if (coverageScope) {
-        tokens.add(coverageScope.trim().toUpperCase());
-    }
-    return tokens;
-}
-function matchesDiscoveryCoverage(recordCountry, areaServed, filterJurisdiction, filterCoverageScope) {
-    const normalizedJurisdiction = normalizeCountryCode(filterJurisdiction);
-    const normalizedCoverageScope = asString(filterCoverageScope).toUpperCase();
-    if (!normalizedJurisdiction && !normalizedCoverageScope)
-        return true;
-    const tokens = buildCoverageTokens(recordCountry, areaServed, undefined);
-    if (normalizedJurisdiction && tokens.has(normalizedJurisdiction))
-        return true;
-    if (normalizedCoverageScope && tokens.has(normalizedCoverageScope))
-        return true;
-    if (normalizedJurisdiction) {
-        const inferred = inferCoverageScopeFromCountryCode(normalizedJurisdiction);
-        if (inferred && tokens.has(inferred.toUpperCase()))
-            return true;
-    }
-    if (normalizedCoverageScope === DataspaceCoverageScope.EuropeanUnion) {
-        if (Array.from(tokens).some((token) => inferCoverageScopeFromCountryCode(token) === DataspaceCoverageScope.EuropeanUnion)) {
-            return true;
-        }
-    }
-    return false;
-}
-function toHostingOperatorCatalog(value) {
-    if (!isObject(value))
-        return null;
-    const providers = value.providers;
-    if (!Array.isArray(providers))
-        return null;
-    const normalizedProviders = providers
-        .filter(isObject)
-        .map((provider) => {
-        const normalized = {
-            providerDid: asString(provider.providerDid),
-            serviceType: asString(provider.serviceType),
-            category: asString(provider.category),
-            areaServed: asString(provider.areaServed) || undefined,
-            endpointUrl: asString(provider.endpointUrl) || undefined,
-            discoveryUrl: asString(provider.discoveryUrl) || undefined,
-            catalogUrl: asString(provider.catalogUrl) || undefined,
-        };
-        return normalized.providerDid && normalized.serviceType && normalized.category
-            ? normalized
-            : null;
-    })
-        .filter((provider) => Boolean(provider));
-    return {
-        hostingOperatorDid: asString(value.hostingOperatorDid) || undefined,
-        discoveryUrl: asString(value.discoveryUrl) || undefined,
-        catalogUrl: asString(value.catalogUrl) || undefined,
-        providers: normalizedProviders,
-    };
-}
-function matchHostingOperatorRecord(record, input) {
-    if (!matchSectorValues(record.categories, input.sector))
-        return false;
-    if (!hasAllTokens(record.serviceTypes, input.requiredCapabilities))
-        return false;
-    if (!matchesDiscoveryCoverage(record.addressCountry, record.areaServed, input.jurisdiction, input.coverageScope))
-        return false;
-    return true;
-}
-function matchPublishedProviderRecord(provider, input) {
-    if (!equalsIgnoreCase(provider.category, input.sector))
-        return false;
-    if (!isProviderServiceCapability(provider.serviceType))
-        return false;
-    if (!equalsIgnoreCase(provider.serviceType, input.providerCapability))
-        return false;
-    if (!matchesDiscoveryCoverage(undefined, provider.areaServed, input.jurisdiction, input.coverageScope))
-        return false;
-    return true;
-}
-/**
- * Concrete node/BFF resolver that combines preloaded hosting-operator records
- * with each host's public service-autodiscovery catalog.
- */
-export class HttpDataspaceResolver extends DataspaceResolver {
-    constructor(options) {
-        super();
-        this.hostingOperators = [...options.hostingOperators];
-        this.fetcher = options.fetcher || globalThis.fetch.bind(globalThis);
-    }
-    /**
-     * Resolves hosting operators from the preloaded semantic records.
-     */
-    async resolveHostingOperators(input) {
-        return this.hostingOperators
-            .filter(({ record }) => matchHostingOperatorRecord(record, input))
-            .map(({ operatorDid, discoveryUrl, record, catalogUrl }) => ({
-            operatorDid,
-            record,
-            matchedCapabilities: (input.requiredCapabilities || []).filter((capability) => record.serviceTypes.some((value) => equalsIgnoreCase(value, capability))),
-            discoveryUrl,
-            catalogUrl,
-        }))
-            .sort((left, right) => left.operatorDid.localeCompare(right.operatorDid));
-    }
-    /**
-     * Resolves published providers by fetching and filtering eligible host public
-     * discovery catalogs.
-     */
-    async resolvePublishedProviders(input) {
-        const eligibleHosts = await this.resolveHostingOperators({
-            sector: input.sector,
-            jurisdiction: input.jurisdiction,
-            coverageScope: input.coverageScope,
-            requiredCapabilities: [input.providerCapability],
-        });
-        const catalogs = await Promise.all(eligibleHosts.map(async (host) => ({
-            host,
-            catalog: await this.fetchCatalog(host.discoveryUrl, host.catalogUrl),
-        })));
-        return catalogs.flatMap(({ host, catalog }) => {
-            if (!catalog)
-                return [];
-            return catalog.providers
-                .filter((record) => matchPublishedProviderRecord(record, input))
-                .map((record) => ({
-                providerDid: record.providerDid,
-                record,
-                hostingOperator: host.record,
-                hostingOperatorDid: host.operatorDid,
-                discoveryUrl: record.discoveryUrl || catalog.discoveryUrl || host.discoveryUrl,
-                catalogUrl: record.catalogUrl || catalog.catalogUrl || host.catalogUrl,
-            }));
-        }).sort((left, right) => left.providerDid.localeCompare(right.providerDid));
-    }
-    /**
-     * Fetches a public discovery catalog for a hosting operator.
-     *
-     * Resolution order:
-     * - canonical DSP entrypoint via `discoveryUrl` (`/.well-known/dspace-version`)
-     * - direct catalog artifact compatibility via `catalogUrl`
-     */
-    async fetchCatalog(discoveryUrl, catalogUrl) {
-        const resolvedCatalogUrl = await this.resolveCatalogArtifactUrl(discoveryUrl, catalogUrl);
-        if (!resolvedCatalogUrl)
-            return undefined;
-        const response = await this.fetcher(resolvedCatalogUrl, {
-            method: 'GET',
-            headers: {
-                accept: 'application/json',
-            },
-        });
-        if (!response.ok) {
-            return undefined;
-        }
-        const body = await response.json();
-        return toHostingOperatorCatalog(body) || undefined;
-    }
-    async resolveCatalogArtifactUrl(discoveryUrl, catalogUrl) {
-        const normalizedDiscoveryUrl = String(discoveryUrl || '').trim();
-        if (normalizedDiscoveryUrl) {
-            if (normalizedDiscoveryUrl.endsWith(DataspaceWellKnownPaths.VersionMetadata)) {
-                const metadata = await this.fetchDspaceVersionMetadata(normalizedDiscoveryUrl);
-                return deriveGwCatalogArtifactUrlFromDspaceVersion(normalizedDiscoveryUrl, metadata, DataspaceProtocolVersions.Current);
-            }
-            return normalizedDiscoveryUrl;
-        }
-        const normalizedCatalogUrl = String(catalogUrl || '').trim();
-        return normalizedCatalogUrl || undefined;
-    }
-    async fetchDspaceVersionMetadata(discoveryUrl) {
-        const response = await this.fetcher(discoveryUrl, {
-            method: 'GET',
-            headers: {
-                accept: 'application/json',
-            },
-        });
-        if (!response.ok) {
-            return undefined;
-        }
-        const body = await response.json();
-        return isDspaceVersionMetadata(body)
-            ? body
-            : undefined;
-    }
-}
-function isDspaceVersionMetadata(value) {
-    if (!isObject(value))
-        return false;
-    return Array.isArray(value.protocolVersions)
-        && value.protocolVersions.every((entry) => isObject(entry) && asString(entry.version) && asString(entry.path));
-}
+export { HttpDataspaceResolver } from 'gdc-sdk-core-ts';

package/dist/discovery/index.d.ts

@@ -1,4 +1 @@
-export * from './DataspaceResolver.js';
-export * from './DefaultFirstDataspaceDiscovery.js';
-export * from './HttpDataspaceResolver.js';
-export * from './types.js';
+export * from 'gdc-sdk-core-ts';

package/dist/discovery/index.js

@@ -1,5 +1,2 @@
 // Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
-export * from './DataspaceResolver.js';
-export * from './DefaultFirstDataspaceDiscovery.js';
-export * from './HttpDataspaceResolver.js';
-export * from './types.js';
+export * from 'gdc-sdk-core-ts';

package/dist/discovery/types.d.ts

@@ -1,96 +1 @@
-import type { DataspaceDiscoveryDefaultsRegistry, DataspaceDiscoveryDefaultsRegistrySeed, DataspaceDiscoveryFilter, HostingOperatorDiscoveryCatalog, HostingOperatorSemanticRecord, PublishedProviderCatalogRecord, TenantServiceSemanticRecord } from 'gdc-common-utils-ts';
-/**
- * Input for resolving hosting operators that can serve a given dataspace use
- * case.
- */
-export type ResolveHostingOperatorsInput = Omit<DataspaceDiscoveryFilter, 'capability'> & Readonly<{
-    requiredCapabilities: readonly string[];
-}>;
-/**
- * Input for resolving publicly published providers through hosting-operator
- * catalogs.
- */
-export type ResolvePublishedProvidersInput = Omit<DataspaceDiscoveryFilter, 'capability' | 'requiredCapabilities'> & Readonly<{
-    providerCapability: string;
-}>;
-/**
- * Preloaded semantic hosting-operator record used by the node runtime to
- * resolve public discovery data without re-parsing VCs.
- */
-export type PreloadedHostingOperatorRecord = Readonly<{
-    operatorDid: string;
-    /**
-     * Canonical DSP discovery entrypoint.
-     *
-     * For GW CORE this should normally be `/.well-known/dspace-version`.
-     */
-    discoveryUrl?: string;
-    /**
-     * @deprecated Prefer `discoveryUrl`. This remains as a compatibility field
-     * for direct catalog artifact URLs.
-     */
-    catalogUrl?: string;
-    record: HostingOperatorSemanticRecord;
-}>;
-/**
- * Runtime configuration for the HTTP-capable dataspace resolver.
- */
-export type HttpDataspaceResolverOptions = Readonly<{
-    hostingOperators: readonly PreloadedHostingOperatorRecord[];
-    fetcher?: typeof fetch;
-    requestHeaders?: Record<string, string>;
-}>;
-/**
- * Minimal request shape for portal/backend discovery calls after defaults have
- * already been configured at startup.
- */
-export type SimpleDataspaceDiscoveryRequest = Readonly<{
-    sector: string;
-    jurisdiction: string;
-    coverageScope?: string;
-}>;
-/**
- * Input for retrieving eligible hosts from the default-first discovery facade.
- */
-export type GetDataspaceHostsInput = SimpleDataspaceDiscoveryRequest & Readonly<{
-    requiredCapabilities?: readonly string[];
-}>;
-/**
- * Construction options for the default-first portal/backend discovery facade.
- *
- * This API intentionally keeps startup configuration separate from the
- * per-request `sector + jurisdiction` queries used later by frontend-facing
- * backends.
- */
-export type DefaultFirstDataspaceDiscoveryOptions = Readonly<{
-    version?: string;
-    networkType: string;
-    defaults?: DataspaceDiscoveryDefaultsRegistry | DataspaceDiscoveryDefaultsRegistrySeed;
-    fetcher?: typeof fetch;
-}>;
-/**
- * Normalized hosting-operator match returned by a node/BFF resolver.
- */
-export type HostingOperatorMatch = Readonly<{
-    operatorDid: string;
-    record: HostingOperatorSemanticRecord;
-    matchedCapabilities: string[];
-    discoveryUrl?: string;
-    catalogUrl?: string;
-}>;
-/**
- * Normalized published-provider match returned by a node/BFF resolver.
- */
-export type PublishedProviderMatch = Readonly<{
-    providerDid: string;
-    record: PublishedProviderCatalogRecord;
-    hostingOperator: HostingOperatorSemanticRecord;
-    hostingOperatorDid: string;
-    discoveryUrl?: string;
-    catalogUrl?: string;
-    tenantSemanticRecord?: TenantServiceSemanticRecord;
-}>;
-/**
- * Shared host catalog shape returned by HTTP discovery endpoints.
- */
-export type HostingOperatorCatalog = HostingOperatorDiscoveryCatalog;
+export type { DefaultFirstDataspaceDiscoveryOptions, GetDataspaceHostsInput, HostingOperatorCatalog, HostingOperatorMatch, HttpDataspaceResolverOptions, PreloadedHostingOperatorRecord, PublishedProviderMatch, ResolveHostingOperatorsInput, ResolvePublishedProvidersInput, SimpleDataspaceDiscoveryRequest, } from 'gdc-sdk-core-ts';

package/dist/index.d.ts

@@ -12,7 +12,6 @@ export * from './resource-operations.js';
 export * from './consent-claim-helpers.js';
 export * from './session.js';
 export * from './node-runtime-client.js';
-export * from './discovery/index.js';
 export * from './gdc-session-bridge.js';
 export * from './orchestration/client-port.js';
 export * from './orchestration/host-onboarding-sdk.js';

package/dist/index.js

@@ -13,7 +13,6 @@ export * from './resource-operations.js';
 export * from './consent-claim-helpers.js';
 export * from './session.js';
 export * from './node-runtime-client.js';
-export * from './discovery/index.js';
 export * from './gdc-session-bridge.js';
 export * from './orchestration/client-port.js';
 export * from './orchestration/host-onboarding-sdk.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdc-sdk-node-ts",
-  "version": "0.8.1",
+  "version": "0.8.3",
   "description": "Next-generation Node runtime package for the GDC SDK family",
   "license": "Apache-2.0",
   "author": "Antifraud Services Inc.",
@@ -17,8 +17,8 @@
     "test:e2e:live-gw": "npm run build && RUN_LIVE_GW_E2E=1 node --test tests/live-gw-node-runtime.e2e.test.mjs"
   },
   "dependencies": {
-    "gdc-common-utils-ts": "^1.16.0",
-    "gdc-sdk-core-ts": "^0.8.1"
+    "gdc-common-utils-ts": "^1.18.1",
+    "gdc-sdk-core-ts": "^0.8.3"
   },
   "devDependencies": {
     "@types/node": "^20.14.10",