@ar.io/sdk 3.22.0-alpha.1 → 3.22.0-alpha.3

package/lib/cjs/cli/cli.js

@@ -448,11 +448,7 @@ const utils_js_1 = require("./utils.js");
 (0, utils_js_1.makeCommand)({
     name: 'get-ants-for-address',
     description: 'Get the list of ANTs owned by an address according to the ANT registry',
-    options: [
-        options_js_1.optionMap.address,
-        options_js_1.optionMap.antRegistryProcessId,
-        options_js_1.optionMap.hyperbeamUrl,
-    ],
+    options: [options_js_1.optionMap.address, options_js_1.optionMap.antRegistryProcessId],
     action: readCommands_js_1.listAntsForAddress,
 });
 // # ANTS

package/lib/cjs/cli/options.js

@@ -339,6 +339,7 @@ exports.globalOptions = [
     exports.optionMap.debug,
     exports.optionMap.arioProcessId,
     exports.optionMap.cuUrl,
+    exports.optionMap.hyperbeamUrl,
 ];
 exports.writeActionOptions = [exports.optionMap.skipConfirmation, exports.optionMap.tags];
 exports.arnsPurchaseOptions = [

package/lib/cjs/cli/utils.js

@@ -181,6 +181,7 @@ function aoProcessFromOptions(options) {
 function readARIOFromOptions(options) {
     setLoggerIfDebug(options);
     return index_js_1.ARIO.init({
+        hyperbeamUrl: options.hyperbeamUrl,
         process: aoProcessFromOptions({
             cuUrl: 'https://cu.ardrive.io', // default to ardrive cu for ARIO process
             ...options,
@@ -227,6 +228,7 @@ function writeARIOFromOptions(options) {
             process: aoProcessFromOptions(options),
             signer,
             paymentUrl: options.paymentUrl,
+            hyperbeamUrl: options.hyperbeamUrl,
         }),
         signerAddress,
     };
@@ -487,6 +489,7 @@ function ANTProcessFromOptions(options) {
 function readANTFromOptions(options) {
     return index_js_1.ANT.init({
         process: ANTProcessFromOptions(options),
+        hyperbeamUrl: options.hyperbeamUrl,
     });
 }
 function writeANTFromOptions(options, signer) {
@@ -494,6 +497,7 @@ function writeANTFromOptions(options, signer) {
     return index_js_1.ANT.init({
         process: ANTProcessFromOptions(options),
         signer,
+        hyperbeamUrl: options.hyperbeamUrl,
     });
 }
 function booleanFromOptions(options, key) {

package/lib/cjs/common/ant.js

@@ -67,6 +67,7 @@ class ANT {
             : false;
         const ario = index_js_2.ARIO.init({
             process: new index_js_2.AOProcess({ processId: arioProcessId, ao }),
+            hyperbeamUrl,
         });
         const getAllAffiliatedNames = async () => {
             let cursor = undefined;
@@ -147,6 +148,7 @@ class ANT {
             logger,
             antRegistryId,
             onSigningProgress,
+            hyperbeamUrl,
         });
         // we could parallelize this, but then signing progress would be harder to track
         const reassignedNames = {};
@@ -471,7 +473,10 @@ class AoANTReadable {
         const currentModuleId = await this.getModuleId({ graphqlUrl, retries });
         // Get all versions from the ANT registry
         const antVersions = ant_versions_js_1.ANTVersions.init({
-            processId: antRegistryId,
+            process: new index_js_2.AOProcess({
+                processId: antRegistryId,
+                ao: this.process.ao,
+            }),
         });
         const versions = await antVersions.getANTVersions();
         // Find the version that matches our module ID
@@ -510,7 +515,10 @@ class AoANTReadable {
         });
         // Get all versions from the ANT registry
         const antVersions = ant_versions_js_1.ANTVersions.init({
-            processId: antRegistryId,
+            process: new index_js_2.AOProcess({
+                processId: antRegistryId,
+                ao: this.process.ao,
+            }),
         });
         const latestVersion = await antVersions.getLatestANTVersion();
         return currentVersion === latestVersion.version;

package/lib/cjs/common/hyperbeam/hb.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HB = void 0;
+const logger_js_1 = require("../logger.js");
+class HB {
+    url;
+    processId;
+    isHyperBeamCompatible;
+    checkHyperBeamPromise;
+    logger;
+    hbTimeoutMs;
+    constructor(config) {
+        this.url = config.url;
+        this.processId = config.processId;
+        this.logger = config.logger ?? logger_js_1.Logger.default;
+        this.hbTimeoutMs = config.hbTimeoutMs ?? 5000;
+        this.isHyperBeamCompatible = undefined;
+        this.checkHyperBeamPromise = this.checkHyperBeamCompatibility();
+    }
+    /**
+     * fetches the meta data for the process
+     *
+     * @returns The meta data for the process
+     *
+     * @example
+     * const hyperbeam = new Hyperbeam({ url: 'https://hyperbeam.ario.permaweb.services', processId: 'qNvAoz0TgcH7DMg8BCVn8jF32QH5L6T29VjHxhHqqGE' });
+     * const meta = await hyperbeam.meta();
+     * console.log(meta);
+     */
+    async meta() {
+        const url = new URL(`${this.url}/${this.processId}~process@1.0/meta`);
+        return this.fetchHyperbeamPath({
+            path: url.toString(),
+        });
+    }
+    /**
+     * calls the process device /now function, which evaluates the current process state pulling new messages
+     * to get the latest state
+     *
+     * @param path - The path to the hb state
+     * @param json - Whether to return the result as JSON, defaults to true
+     * @returns The result of the compute operation
+     *
+     * @example
+     * const hyperbeam = new Hyperbeam({ url: 'https://hyperbeam.ario.permaweb.services', processId: 'qNvAoz0TgcH7DMg8BCVn8jF32QH5L6T29VjHxhHqqGE' });
+     * const result = await hyperbeam.now({ path: 'balances/QGWqtJdLLgm2ehFWiiPzMaoFLD50CnGuzZIPEdoDRGQ' });
+     * console.log(result);
+     */
+    async now({ path, json = false, }) {
+        return this.fetchHyperbeamPath({
+            path: `${this.url}/${this.processId}~process@1.0/now/${path}`,
+            json,
+        });
+    }
+    /**
+     * calls the process device /compute function, which uses the currently evaluated state in the node
+     *
+     * @param path - The path to the compute resource
+     * @param json - Whether to return the result as JSON, defaults to true
+     * @returns The result of the compute operation
+     *
+     * @example
+     * const hyperbeam = new Hyperbeam({ url: 'https://hyperbeam.ario.permaweb.services', processId: 'qNvAoz0TgcH7DMg8BCVn8jF32QH5L6T29VjHxhHqqGE' });
+     * const result = await hyperbeam.compute({ path: 'balances/QGWqtJdLLgm2ehFWiiPzMaoFLD50CnGuzZIPEdoDRGQ' });
+     * console.log(result);
+     */
+    async compute({ path, json = false, }) {
+        return this.fetchHyperbeamPath({
+            path: `${this.url}/${this.processId}~process@1.0/compute/${path}`,
+            json,
+        });
+    }
+    /**
+     * Checks if the process is HyperBeam compatible and caches the result.
+     *
+     * @returns {Promise<boolean>} True if the process is HyperBeam compatible, false otherwise.
+     */
+    async checkHyperBeamCompatibility({ minSlot, } = {}) {
+        // refetch if min slot is provided
+        if (minSlot !== undefined) {
+            this.isHyperBeamCompatible = undefined;
+            this.checkHyperBeamPromise = undefined;
+        }
+        if (this.checkHyperBeamPromise !== undefined) {
+            return this.checkHyperBeamPromise;
+        }
+        if (this.isHyperBeamCompatible !== undefined) {
+            return Promise.resolve(this.isHyperBeamCompatible);
+        }
+        const result = fetch(
+        // use /now to force a refresh of the cache state, then compute when calling it for keys
+        `${this.url.toString()}/${this.processId}~process@1.0/now`, {
+            method: 'HEAD',
+            signal: AbortSignal.timeout(this.hbTimeoutMs),
+        })
+            .then(async (res) => {
+            if (res.ok) {
+                if (minSlot !== undefined) {
+                    const slotRes = await this.compute({
+                        path: 'at-slot',
+                        json: false,
+                    });
+                    const slot = Number(slotRes);
+                    if (slot < minSlot) {
+                        return false;
+                    }
+                }
+                this.isHyperBeamCompatible = true;
+                return true;
+            }
+            this.isHyperBeamCompatible = false;
+            return false;
+        })
+            .catch((error) => {
+            this.logger.debug('Failed to check HyperBeam compatibility', {
+                cause: error,
+            });
+            this.isHyperBeamCompatible = false;
+            return false;
+        });
+        this.checkHyperBeamPromise = result;
+        return result;
+    }
+    async fetchHyperbeamPath({ path, json = true, }) {
+        try {
+            const url = new URL(path);
+            if (json) {
+                this.logger.debug('Fetching path as JSON', { path });
+                /**
+                 * This is the (current) way to access data as json
+                 * the old way is /~json@1.0/serialize path
+                 */
+                url.searchParams.set('require-codec', 'application/json');
+                url.searchParams.set('accept-bundle', 'true');
+                const res = await fetch(url);
+                if (!res.ok) {
+                    throw new Error(`Failed to fetch path as JSON: ${res.statusText}`);
+                }
+                const jsonResult = await res
+                    .json()
+                    .then((json) => json)
+                    .catch((error) => {
+                    this.logger.error('Failed to parse JSON', {
+                        cause: error,
+                    });
+                    throw new Error(`Received response but failed to parse JSON: ${error.message}`);
+                });
+                if (typeof jsonResult !== 'object' ||
+                    jsonResult === null ||
+                    !('body' in jsonResult)) {
+                    throw new Error('Response body missing in JSON response');
+                }
+                return jsonResult.body;
+            }
+            else {
+                this.logger.debug('Fetching path as text', { path });
+                const res = await fetch(url);
+                if (!res.ok) {
+                    throw new Error(`Failed to fetch path: ${res.statusText}`);
+                }
+                const body = await res.text();
+                return body;
+            }
+        }
+        catch (error) {
+            this.logger.error('Failed to fetch path as JSON', {
+                cause: error,
+            });
+            throw error;
+        }
+    }
+}
+exports.HB = HB;

package/lib/cjs/common/io.js

@@ -27,6 +27,7 @@ const arweave_js_2 = require("./arweave.js");
 const ao_process_js_1 = require("./contracts/ao-process.js");
 const error_js_1 = require("./error.js");
 const faucet_js_1 = require("./faucet.js");
+const hb_js_1 = require("./hyperbeam/hb.js");
 const logger_js_1 = require("./logger.js");
 const turbo_js_1 = require("./turbo.js");
 class ARIO {
@@ -104,9 +105,9 @@ class ARIOReadable {
     hyperbeamUrl;
     paymentProvider; // TODO: this could be an array/map of payment providers
     logger = logger_js_1.Logger.default;
+    hb;
     constructor(config) {
         this.arweave = config?.arweave ?? arweave_js_2.defaultArweave;
-        this.hyperbeamUrl = config?.hyperbeamUrl;
         if (config === undefined || Object.keys(config).length === 0) {
             this.process = new ao_process_js_1.AOProcess({
                 processId: constants_js_1.ARIO_MAINNET_PROCESS_ID,
@@ -123,6 +124,19 @@ class ARIOReadable {
         else {
             throw new error_js_1.InvalidContractConfigurationError();
         }
+        // only use hyperbeam if the client has provided a hyperbeamUrl
+        // this will avoid overwhelming the HyperBeam node with requests
+        // as we shift using HyperBEAM for all ANT operations
+        if (config?.hyperbeamUrl !== undefined) {
+            this.hyperbeamUrl = config.hyperbeamUrl;
+            this.hb = new hb_js_1.HB({
+                url: this.hyperbeamUrl,
+                processId: this.process.processId,
+            });
+            this.logger.debug(`Using HyperBEAM node for process ${this.process.processId}`, {
+                hyperbeamUrl: this.hyperbeamUrl,
+            });
+        }
         this.paymentProvider = turbo_js_1.TurboArNSPaymentFactory.init({
             paymentUrl: config?.paymentUrl,
         });
@@ -222,6 +236,24 @@ class ARIOReadable {
         });
     }
     async getBalance({ address }) {
+        if (this.hb && (await this.hb.checkHyperBeamCompatibility())) {
+            this.logger.debug('Getting balance from HyperBEAM', { address });
+            const res = await this.hb
+                .compute({
+                path: `balances/${address}`,
+            })
+                .then((res) => Number(res))
+                .catch((error) => {
+                this.logger.error('Failed to get balance from HyperBEAM', {
+                    cause: error,
+                });
+                return null;
+            });
+            if (res !== null)
+                return res;
+            // else fall through to CU read
+            this.logger.info('Failed to get balance from HyperBEAM, failing over to to CU read', { address });
+        }
         return this.process.read({
             tags: [
                 { name: 'Action', value: 'Balance' },
@@ -649,6 +681,7 @@ class ARIOReadable {
                 ao: this.process.ao,
                 processId: nameData.processId,
             }),
+            hyperbeamUrl: this.hyperbeamUrl,
         });
         const [owner, antRecord] = await Promise.all([
             ant.getOwner(),
@@ -1286,6 +1319,7 @@ class ARIOWriteable extends ARIOReadable {
                 ao: this.process.ao,
             }),
             signer: this.signer,
+            hyperbeamUrl: this.hyperbeamUrl,
         });
         // approve the primary name request with the ant
         const approveResult = await antClient.approvePrimaryNameRequest({

package/lib/cjs/utils/ao.js

@@ -39,7 +39,7 @@ async function spawnANT({ signer, module, ao = (0, aoconnect_1.connect)({
     MODE: 'legacy',
 }), scheduler = constants_js_1.DEFAULT_SCHEDULER_ID, state, tags = [], antRegistryId = constants_js_1.ANT_REGISTRY_ID, logger = index_js_1.Logger.default, authority = constants_js_1.AO_AUTHORITY, onSigningProgress = (name, payload) => {
     logger.debug('Signing progress', { name, payload });
-}, }) {
+}, hyperbeamUrl, }) {
     if (state) {
         (0, schema_js_1.parseSchemaResult)(ant_js_1.SpawnANTStateSchema, state);
     }
@@ -194,7 +194,12 @@ async function spawnANT({ signer, module, ao = (0, aoconnect_1.connect)({
     // check the ACL for the owner
     const antRegistry = ant_registry_js_1.ANTRegistry.init({
         signer,
-        processId: antRegistryId,
+        process: new index_js_1.AOProcess({
+            processId: antRegistryId,
+            ao,
+            logger,
+        }),
+        hyperbeamUrl,
     });
     let attempts = 0;
     const maxAttempts = 5;
@@ -225,7 +230,7 @@ async function spawnANT({ signer, module, ao = (0, aoconnect_1.connect)({
 }
 async function forkANT({ signer, antProcessId, logger = index_js_1.Logger.default, ao, moduleId, antRegistryId = constants_js_1.ANT_REGISTRY_ID, onSigningProgress = (name, payload) => {
     logger.debug('Forking ANT', { name, payload });
-}, }) {
+}, hyperbeamUrl, }) {
     // get the state of the current ANT and use it to spawn a new ANT
     const ant = index_js_1.ANT.init({
         process: new index_js_1.AOProcess({
@@ -233,6 +238,7 @@ async function forkANT({ signer, antProcessId, logger = index_js_1.Logger.defaul
             ao,
             logger,
         }),
+        hyperbeamUrl,
     });
     const state = await ant.getState();
     if (state === undefined) {
@@ -256,6 +262,7 @@ async function forkANT({ signer, antProcessId, logger = index_js_1.Logger.defaul
             balances: state.Balances,
             logo: state.Logo,
         },
+        hyperbeamUrl,
     });
     return forkedProcessId;
 }

package/lib/cjs/version.js

@@ -17,4 +17,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = void 0;
 // AUTOMATICALLY GENERATED FILE - DO NOT TOUCH
-exports.version = '3.22.0-alpha.1';
+exports.version = '3.22.0-alpha.3';

package/lib/esm/cli/cli.js

@@ -446,11 +446,7 @@ makeCommand({
 makeCommand({
     name: 'get-ants-for-address',
     description: 'Get the list of ANTs owned by an address according to the ANT registry',
-    options: [
-        optionMap.address,
-        optionMap.antRegistryProcessId,
-        optionMap.hyperbeamUrl,
-    ],
+    options: [optionMap.address, optionMap.antRegistryProcessId],
     action: listAntsForAddress,
 });
 // # ANTS

package/lib/esm/cli/options.js

@@ -336,6 +336,7 @@ export const globalOptions = [
     optionMap.debug,
     optionMap.arioProcessId,
     optionMap.cuUrl,
+    optionMap.hyperbeamUrl,
 ];
 export const writeActionOptions = [optionMap.skipConfirmation, optionMap.tags];
 export const arnsPurchaseOptions = [

package/lib/esm/cli/utils.js

@@ -127,6 +127,7 @@ function aoProcessFromOptions(options) {
 export function readARIOFromOptions(options) {
     setLoggerIfDebug(options);
     return ARIO.init({
+        hyperbeamUrl: options.hyperbeamUrl,
         process: aoProcessFromOptions({
             cuUrl: 'https://cu.ardrive.io', // default to ardrive cu for ARIO process
             ...options,
@@ -173,6 +174,7 @@ export function writeARIOFromOptions(options) {
             process: aoProcessFromOptions(options),
             signer,
             paymentUrl: options.paymentUrl,
+            hyperbeamUrl: options.hyperbeamUrl,
         }),
         signerAddress,
     };
@@ -433,6 +435,7 @@ function ANTProcessFromOptions(options) {
 export function readANTFromOptions(options) {
     return ANT.init({
         process: ANTProcessFromOptions(options),
+        hyperbeamUrl: options.hyperbeamUrl,
     });
 }
 export function writeANTFromOptions(options, signer) {
@@ -440,6 +443,7 @@ export function writeANTFromOptions(options, signer) {
     return ANT.init({
         process: ANTProcessFromOptions(options),
         signer,
+        hyperbeamUrl: options.hyperbeamUrl,
     });
 }
 export function booleanFromOptions(options, key) {

package/lib/esm/common/ant.js

@@ -64,6 +64,7 @@ export class ANT {
             : false;
         const ario = ARIO.init({
             process: new AOProcess({ processId: arioProcessId, ao }),
+            hyperbeamUrl,
         });
         const getAllAffiliatedNames = async () => {
             let cursor = undefined;
@@ -144,6 +145,7 @@ export class ANT {
             logger,
             antRegistryId,
             onSigningProgress,
+            hyperbeamUrl,
         });
         // we could parallelize this, but then signing progress would be harder to track
         const reassignedNames = {};
@@ -467,7 +469,10 @@ export class AoANTReadable {
         const currentModuleId = await this.getModuleId({ graphqlUrl, retries });
         // Get all versions from the ANT registry
         const antVersions = ANTVersions.init({
-            processId: antRegistryId,
+            process: new AOProcess({
+                processId: antRegistryId,
+                ao: this.process.ao,
+            }),
         });
         const versions = await antVersions.getANTVersions();
         // Find the version that matches our module ID
@@ -506,7 +511,10 @@ export class AoANTReadable {
         });
         // Get all versions from the ANT registry
         const antVersions = ANTVersions.init({
-            processId: antRegistryId,
+            process: new AOProcess({
+                processId: antRegistryId,
+                ao: this.process.ao,
+            }),
         });
         const latestVersion = await antVersions.getLatestANTVersion();
         return currentVersion === latestVersion.version;

package/lib/esm/common/hyperbeam/hb.js

@@ -0,0 +1,169 @@
+import { Logger } from '../logger.js';
+export class HB {
+    url;
+    processId;
+    isHyperBeamCompatible;
+    checkHyperBeamPromise;
+    logger;
+    hbTimeoutMs;
+    constructor(config) {
+        this.url = config.url;
+        this.processId = config.processId;
+        this.logger = config.logger ?? Logger.default;
+        this.hbTimeoutMs = config.hbTimeoutMs ?? 5000;
+        this.isHyperBeamCompatible = undefined;
+        this.checkHyperBeamPromise = this.checkHyperBeamCompatibility();
+    }
+    /**
+     * fetches the meta data for the process
+     *
+     * @returns The meta data for the process
+     *
+     * @example
+     * const hyperbeam = new Hyperbeam({ url: 'https://hyperbeam.ario.permaweb.services', processId: 'qNvAoz0TgcH7DMg8BCVn8jF32QH5L6T29VjHxhHqqGE' });
+     * const meta = await hyperbeam.meta();
+     * console.log(meta);
+     */
+    async meta() {
+        const url = new URL(`${this.url}/${this.processId}~process@1.0/meta`);
+        return this.fetchHyperbeamPath({
+            path: url.toString(),
+        });
+    }
+    /**
+     * calls the process device /now function, which evaluates the current process state pulling new messages
+     * to get the latest state
+     *
+     * @param path - The path to the hb state
+     * @param json - Whether to return the result as JSON, defaults to true
+     * @returns The result of the compute operation
+     *
+     * @example
+     * const hyperbeam = new Hyperbeam({ url: 'https://hyperbeam.ario.permaweb.services', processId: 'qNvAoz0TgcH7DMg8BCVn8jF32QH5L6T29VjHxhHqqGE' });
+     * const result = await hyperbeam.now({ path: 'balances/QGWqtJdLLgm2ehFWiiPzMaoFLD50CnGuzZIPEdoDRGQ' });
+     * console.log(result);
+     */
+    async now({ path, json = false, }) {
+        return this.fetchHyperbeamPath({
+            path: `${this.url}/${this.processId}~process@1.0/now/${path}`,
+            json,
+        });
+    }
+    /**
+     * calls the process device /compute function, which uses the currently evaluated state in the node
+     *
+     * @param path - The path to the compute resource
+     * @param json - Whether to return the result as JSON, defaults to true
+     * @returns The result of the compute operation
+     *
+     * @example
+     * const hyperbeam = new Hyperbeam({ url: 'https://hyperbeam.ario.permaweb.services', processId: 'qNvAoz0TgcH7DMg8BCVn8jF32QH5L6T29VjHxhHqqGE' });
+     * const result = await hyperbeam.compute({ path: 'balances/QGWqtJdLLgm2ehFWiiPzMaoFLD50CnGuzZIPEdoDRGQ' });
+     * console.log(result);
+     */
+    async compute({ path, json = false, }) {
+        return this.fetchHyperbeamPath({
+            path: `${this.url}/${this.processId}~process@1.0/compute/${path}`,
+            json,
+        });
+    }
+    /**
+     * Checks if the process is HyperBeam compatible and caches the result.
+     *
+     * @returns {Promise<boolean>} True if the process is HyperBeam compatible, false otherwise.
+     */
+    async checkHyperBeamCompatibility({ minSlot, } = {}) {
+        // refetch if min slot is provided
+        if (minSlot !== undefined) {
+            this.isHyperBeamCompatible = undefined;
+            this.checkHyperBeamPromise = undefined;
+        }
+        if (this.checkHyperBeamPromise !== undefined) {
+            return this.checkHyperBeamPromise;
+        }
+        if (this.isHyperBeamCompatible !== undefined) {
+            return Promise.resolve(this.isHyperBeamCompatible);
+        }
+        const result = fetch(
+        // use /now to force a refresh of the cache state, then compute when calling it for keys
+        `${this.url.toString()}/${this.processId}~process@1.0/now`, {
+            method: 'HEAD',
+            signal: AbortSignal.timeout(this.hbTimeoutMs),
+        })
+            .then(async (res) => {
+            if (res.ok) {
+                if (minSlot !== undefined) {
+                    const slotRes = await this.compute({
+                        path: 'at-slot',
+                        json: false,
+                    });
+                    const slot = Number(slotRes);
+                    if (slot < minSlot) {
+                        return false;
+                    }
+                }
+                this.isHyperBeamCompatible = true;
+                return true;
+            }
+            this.isHyperBeamCompatible = false;
+            return false;
+        })
+            .catch((error) => {
+            this.logger.debug('Failed to check HyperBeam compatibility', {
+                cause: error,
+            });
+            this.isHyperBeamCompatible = false;
+            return false;
+        });
+        this.checkHyperBeamPromise = result;
+        return result;
+    }
+    async fetchHyperbeamPath({ path, json = true, }) {
+        try {
+            const url = new URL(path);
+            if (json) {
+                this.logger.debug('Fetching path as JSON', { path });
+                /**
+                 * This is the (current) way to access data as json
+                 * the old way is /~json@1.0/serialize path
+                 */
+                url.searchParams.set('require-codec', 'application/json');
+                url.searchParams.set('accept-bundle', 'true');
+                const res = await fetch(url);
+                if (!res.ok) {
+                    throw new Error(`Failed to fetch path as JSON: ${res.statusText}`);
+                }
+                const jsonResult = await res
+                    .json()
+                    .then((json) => json)
+                    .catch((error) => {
+                    this.logger.error('Failed to parse JSON', {
+                        cause: error,
+                    });
+                    throw new Error(`Received response but failed to parse JSON: ${error.message}`);
+                });
+                if (typeof jsonResult !== 'object' ||
+                    jsonResult === null ||
+                    !('body' in jsonResult)) {
+                    throw new Error('Response body missing in JSON response');
+                }
+                return jsonResult.body;
+            }
+            else {
+                this.logger.debug('Fetching path as text', { path });
+                const res = await fetch(url);
+                if (!res.ok) {
+                    throw new Error(`Failed to fetch path: ${res.statusText}`);
+                }
+                const body = await res.text();
+                return body;
+            }
+        }
+        catch (error) {
+            this.logger.error('Failed to fetch path as JSON', {
+                cause: error,
+            });
+            throw error;
+        }
+    }
+}